<Xach>
it has many users who can help with specific issues
<akkad>
ahh cl implementation. yeah sbcl is pretty much it.
<pillton>
granttrec: This channel is about common lisp. Clojure is not an implementation of common lisp.
<granttrec>
akkad: well this is going to be fun :)
<akkad>
At the request of John McCarthy, Lisp’s creator, no single language that is a member of the Lisp family is to be intended to be the definitive dialect; that is, none is to be called just “LISP.”
mathZ has joined #lisp
<akkad>
but we said "he's dead, let's violate this request"
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
karlosz has joined #lisp
fikka has joined #lisp
lemoinem has quit [Ping timeout: 248 seconds]
<akkad>
there is a page that shows the differences between the lisps. to give you a feel for it
<granttrec>
akkad: not be to off topic but do peopel program in emaxs lisp outside of hacking the editor?
<Xach>
that is a question for #emacs
<akkad>
yeah that channel is never on topic. :P
lemoinem has joined #lisp
<akkad>
granttrec: #lispcafe too
<LdBeth>
That’s not Donald Kurth and TeX
<LdBeth>
akkad: I never heard such a claimer
<akkad>
LdBeth: what claimer?
fikka has joined #lisp
<akkad>
google it
<aeth>
akkad: This comes up from time to time. Afaik, the historical Lisps that led up to Common Lisp like Maclisp and Lisp Machine Lisp are also on topic in #lisp, it's just that obviously they come up much less frequently.
<aeth>
So it's not 100% exclusively Common Lisp.
markoong has quit [Ping timeout: 265 seconds]
<akkad>
but cl is what's on topic here, no?
<akkad>
and not even ALL cl, just sbcl
<aeth>
Since most modern Lisps deviate significantly from the tradition (Common Lisp represents the tradition + an object system), there isn't really the demand for a channel that just involves Lisps in general. There is one, ##lisp is its name, and it was (when I was in it) quite dead. #scheme is similarly not very active compared to the individual Scheme channels.
<aeth>
Broad topic channels are only of interest to language implementors, really.
<aeth>
akkad: As I said, and you might get a different answer depending on who's on, last time this came up and I was here, people said that precursor languages to CL are on topic. And I have shared historic Lisp material here before iirc.
wigust has joined #lisp
<aeth>
Common Lisp represents a Lisp tradition that very few other living Lisps follow. Maybe Emacs Lisp. Scheme is probably the next closest, if you ignore that it renamed practically every procedure and has slightly different terminology (like "procedure", "pair" instead of "cons", etc.)
* akkad
got asked to not mention allegro or lispworks here
fikka has quit [Ping timeout: 240 seconds]
<aeth>
akkad: Implementation-specific issues go to implementation-specific channels. I go to #sbcl when I have a question about an SBCL extension or something.
lemoinem has joined #lisp
<aeth>
Also, CCL is quite popular here.
<LdBeth>
Okay I see
<pillton>
Why would Lispworks and Allegro CL be offtopic here?
<aeth>
If there was a survey here, it'd probably be 60% SBCL and 30% CCL. 2:1 is a lot, but that's the impression I get here. Other methods seem to suggest perhaps 10:1 SBCL:CCL, so if anything CCLers are overrepresented here. (Concrete numbers would be hard to obtain, though.)
fikka has joined #lisp
<aeth>
pillton: I'm guessing akkad is referring to a LW-specific or Allegro-specific question
<pillton>
aeth: OK. Fair enough.
siraben has joined #lisp
zachk has quit [Quit: Leaving]
rpg has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<akkad>
pillton: was told they were not opensource, thus off topic for freenode. despite the fact that the ##lisp would be the "opensource" channel
siraben has quit [Client Quit]
siraben has joined #lisp
SaganMan has joined #lisp
fikka has joined #lisp
<pillton>
Hmm, that seems a bit unfair.
<akkad>
</qq>
fikka has quit [Ping timeout: 264 seconds]
FreeBirdLjj has joined #lisp
siraben has quit [Quit: ERC (IRC client for Emacs 26.1)]
siraben has joined #lisp
Khisanth has quit [Ping timeout: 248 seconds]
tokenrove has quit [Ping timeout: 240 seconds]
tokenrove has joined #lisp
fikka has joined #lisp
elfmacs has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 264 seconds]
Khisanth has joined #lisp
Kundry_Wag has joined #lisp
eli_oat has quit [Quit: Leaving.]
mange has joined #lisp
fikka has joined #lisp
slyrus has quit [Quit: slyrus]
dented42 has joined #lisp
<pierpa>
uh? so the topic of this channel is "common lisp except lispworks and allegro"?
<Bike>
well, the idea is that freenode is for open source stuff.
fikka has quit [Ping timeout: 245 seconds]
<Bike>
and regardless of that, it seems likely that you can get better specific advice about lispworks and allegro from their official mailing lists and help lines and such.
<pierpa>
yeah, let's alienate some of the 12 cl programmers that remain in the world.
<Xach>
pierpa: Some feel more strongly about the freenode conditions of use than others.
ealfonso has joined #lisp
<Xach>
This is not a great place for discussion of allegro and lispworks mostly because there are few users here, but partly because it is not what freenode is for.
<Xach>
The former dominates the latter.
jibanes has quit [Ping timeout: 268 seconds]
jibanes has joined #lisp
fikka has joined #lisp
ealfonso has quit [Remote host closed the connection]
ealfonso has joined #lisp
vhost- has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 276 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
mathZ has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
cgay_ has joined #lisp
wigust has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rpg has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
dented42 has joined #lisp
dented42 has quit [Client Quit]
shangul has joined #lisp
vhost- has joined #lisp
vhost- has joined #lisp
vhost- has quit [Changing host]
eli_oat has joined #lisp
fikka has joined #lisp
shifty has joined #lisp
eli_oat has quit [Ping timeout: 265 seconds]
fikka has quit [Ping timeout: 265 seconds]
eli_oat has joined #lisp
fikka has joined #lisp
eli_oat has quit [Quit: Leaving.]
subroot has quit [Read error: Connection reset by peer]
<akkad>
and freenode, as defined by rob was for ## to be for the opensource, and # to not be
<akkad>
umm... Freenode policy since rob converted from linpeople.org to freenode back in 99
FreeBirdLjj has quit [Remote host closed the connection]
robotoad has quit [Quit: robotoad]
akkad has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
akkad has joined #lisp
<akkad>
oh I see.
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
robotoad has joined #lisp
eli_oat has joined #lisp
fkac has joined #lisp
<akkad>
how things have changed. Aug 02 15:30:47 2002 #lisp 67 The open source lisp-wiki: http://ww.telent.net/cliki/ - sbcl 0.7.6 out - clisp 2.29 out - new site: www.lispworks.com
Kundry_W_ has joined #lisp
<fkac>
Ew clisp
fikka has joined #lisp
Kundry_W_ has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 256 seconds]
Ober has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
koenig has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 256 seconds]
fisxoj has joined #lisp
granttrec has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
fikka has joined #lisp
eli_oat has quit [Quit: Leaving.]
pierpa has quit [Quit: Page closed]
lemoinem has quit [Ping timeout: 268 seconds]
shka_ has joined #lisp
lemoinem has joined #lisp
skapata has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
eli_oat has joined #lisp
fikka has joined #lisp
brendyn has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
Jesin has quit [Quit: Leaving]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<beach>
Good morning everyone!
zaquest has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
eli_oat has quit [Quit: Leaving.]
<akkad>
hey beach
schoppenhauer has quit [Ping timeout: 260 seconds]
<makomo>
beach: morning!
schoppenhauer has joined #lisp
DataLinkDroid2 has joined #lisp
DataLinkDroid has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
eli_oat has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<Ober>
beach: hi.
fikka has joined #lisp
azimut has quit [Ping timeout: 264 seconds]
eli_oat has quit [Quit: Leaving.]
AetherWind has joined #lisp
eli_oat has joined #lisp
AetherWind has left #lisp [#lisp]
azimut has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Naergon_ has joined #lisp
Naergon has quit [Ping timeout: 245 seconds]
eli_oat has quit [Quit: Leaving.]
fikka has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
ealfonso has quit [Ping timeout: 260 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
fisxoj has quit [Quit: fisxoj]
vtomole has joined #lisp
<LdBeth>
Is it possible to specify type for certain symbols, e.g. for symbol 'YES and 'NO, they have type 'Y-OR-N
AetherWind has joined #lisp
<beach>
Sure.
<pillton>
Sure: (typep 'yes '(member yes no))
<LdBeth>
Thanks
<pillton>
Then you can use deftype to create 'y-or-n. (deftype y-or-n () '(member yes no))
fikka has joined #lisp
<LdBeth>
So can I add or del symbols to that type defined
<pillton>
Absolutely. At runtime if you wish as well.
fikka has quit [Ping timeout: 268 seconds]
<LdBeth>
Seems I can use a function to check the type and then hack that function
<pillton>
What are you trying to do?
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<LdBeth>
I want to write a TCG card game, there’s certain attributes I want to check if is valid at runtime and retain the ability adding new attributes
dented42 has joined #lisp
<on_ion>
cool =)
<beach>
It doesn't sound like using types would be good for situations like that.
<LdBeth>
beach: yes, so I use instance and do after initialize check currently
<beach>
I see a lot of potential clashes with Common Lisp symbols.
<beach>
But I guess you shadow them in your package definition.
<beach>
And I guess I don't see the purpose of the new metaclass, but that's probably normal, since I don't understand what the code is doing.
fikka has joined #lisp
pjb has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 276 seconds]
<LdBeth>
beach: I use metaclass because I want to avoid introducing a lot of global variables. That additional slot of metaclass stores allowed content
<LdBeth>
Maybe it’s a abuse.
<LdBeth>
(defdata foo '(a b c))
<LdBeth>
(make-instance 'foo :content a) ;; => valid
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
Why can't that just be a slot with :allocation :class?
igemnace has joined #lisp
shka_ has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
sauvin has joined #lisp
<beach>
Anyway, I should quit pestering you, since I don't really understand the code.
<LdBeth>
Never mind, just a personal interested project.
<LdBeth>
beach: I didn’t noticed :allocation. Seems to be a good idea
fikka has quit [Ping timeout: 256 seconds]
whartung has quit [Read error: Connection reset by peer]
whartung has joined #lisp
defaultxr has quit [Remote host closed the connection]
jeosol has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
defaultxr has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
shangul has quit [Remote host closed the connection]
shangul has joined #lisp
kajo has joined #lisp
Inline has quit [Quit: Leaving]
vtomole has quit [Ping timeout: 260 seconds]
surya has quit [Remote host closed the connection]
cgay_ has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
heisig has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
shangul has quit [Remote host closed the connection]
fikka has joined #lisp
lugh has quit [Quit: quitting bouncer]
makomo has quit [Ping timeout: 240 seconds]
lugh has joined #lisp
kajo has quit [Ping timeout: 256 seconds]
lugh has quit [Client Quit]
fikka has quit [Ping timeout: 268 seconds]
flamebeard has joined #lisp
lugh has joined #lisp
andrei-n has joined #lisp
fraya has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
siraben has quit [Remote host closed the connection]
siraben has joined #lisp
fikka has joined #lisp
Cymew has joined #lisp
Cymew has quit [Ping timeout: 255 seconds]
lugh is now known as thoth
thodg has joined #lisp
kushal has quit [Write error: Connection reset by peer]
kushal has joined #lisp
robotoad has quit [Quit: robotoad]
Cymew has joined #lisp
gls_ has left #lisp [#lisp]
eminhi has joined #lisp
vlatkoB has joined #lisp
siraben has quit [Quit: ERC (IRC client for Emacs 26.1)]
Folkol has joined #lisp
jeosol has joined #lisp
thodg has quit [Ping timeout: 256 seconds]
mn3m has joined #lisp
mansalss has quit [Ping timeout: 245 seconds]
kajo has joined #lisp
mange has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
<shka>
does clrhash in sbcl actually frees the memory?
<beach>
It can't.
<beach>
... other than perhaps the fairly small amount of memory for the has table itself.
<beach>
But it probably doesn't bother.
<beach>
Otherwise, keys and values can be shared, so it can't free that memory.
Folkol has quit [Ping timeout: 264 seconds]
surya has joined #lisp
<shka>
beach: well, maybe i should rephrase my question
<shka>
by freeing memory i thinked about hash-table-size
<shka>
but i can actually check that
<beach>
Oh, that's different.
attila_lendvai has quit [Read error: Connection reset by peer]
mansalss has joined #lisp
<shka>
it is
<shka>
i think it shouldn't
<shka>
because it would not be different from making fresh hash-table
<shka>
besides maybe convinience
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
<beach>
And preserving identity.
attila_lendvai has quit [Read error: Connection reset by peer]
<jackdaniel>
from the "under the hood" perspective it is different. clrhash mutates hashtable object, while creating fesh hash-table constructs whole new one
<beach>
That's what I meant by preserving identity.
<jackdaniel>
also if you have more references to that hashtable in your program, then clrhash will clear all of them
<jackdaniel>
yes
attila_lendvai has joined #lisp
<jackdaniel>
s/all of them/"all of them"/
<shka>
obviously
<shka>
but rehashing is killing me
<shka>
and I am sure that i won't need smaller hash-table
<shka>
so what bothers me are internals
hhdave has joined #lisp
Folkol has joined #lisp
<jackdaniel>
if you set integer as rehash size, then you should avoid frequent rehashing
<jackdaniel>
given I understand correctly your dillema
<jackdaniel>
(of you should know beforehand what this integer value should be)
<jmercouris>
flip214: I believe there is a lisp version somewhere
fikka has joined #lisp
rpg has joined #lisp
kushal has joined #lisp
flamebeard has quit []
fikka has quit [Ping timeout: 240 seconds]
flamebeard has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
fraya has quit [Remote host closed the connection]
Bike is now known as Bicyclidine
elfmacs has quit [Read error: Connection reset by peer]
cgay_ has joined #lisp
omilu has joined #lisp
makomo has joined #lisp
varjag has quit [Ping timeout: 245 seconds]
umpc has quit [Ping timeout: 245 seconds]
umpc has joined #lisp
heisig has quit [Quit: Leaving]
obicons has joined #lisp
EvW has joined #lisp
<jmercouris>
can someone explain how (list 'quote 'foo) -> 'FOO ?
<jmercouris>
I imagine it would do (quote foo)
<jmercouris>
which I would thereafter imagine would become just FOO
<jmercouris>
ah I get it
<jmercouris>
because 'FOO is shorthand for (quote foo)
<Xach>
jes
shifty has quit [Ping timeout: 245 seconds]
<jmercouris>
I have to say I really prefer (quote x) than 'x
<shka>
jmercouris: you will grow out of it
fikka has quit [Ping timeout: 245 seconds]
<jmercouris>
maybe
<jackdaniel>
left-parenthesis quote x right-parenthesis ; beats all ;)
<jmercouris>
you can type out left-parenthesis?
<jmercouris>
damnit, I just tried it in my repl lo
<jmercouris>
you got me lol
<jmercouris>
I guess one could define a macro
varjag has joined #lisp
<jmercouris>
are symbols objects?
<shka>
yes, why not?
<jmercouris>
I don't see why not
<jmercouris>
I was just wondering
<jmercouris>
it seems like they would be
<shka>
sure they are
thawes has joined #lisp
<jmercouris>
is the function pointed to by a symbol stored in a slot of that symbol?
<jackdaniel>
symbol is a built-in class
Bike has joined #lisp
fikka has joined #lisp
<jackdaniel>
it means that it doesn't have to be a standard-class
quazimodo has quit [Ping timeout: 264 seconds]
<jmercouris>
when we assign a variable to a symbol, are we instantiating a new object of the class symbol?
<phoe>
jmercouris: wait
<phoe>
assign a variable to a symbol?
<phoe>
variables have nothing to do with object instantiation
<jackdaniel>
built-in class means: we pretened it is a class, but in fact it is internal datatype with shoehoerned aspects allowing dispatch on it
<phoe>
or symbol instantiation
<jmercouris>
jackdaniel: Ok, that is good to know, I'll put that in my notes thank you
<phoe>
symbols are usually created at read-time
<jmercouris>
well for example, when we enter a function body
<jmercouris>
we are assigning a symbol to some variable value
<Bike>
no
<phoe>
jmercouris: yes, but the symbols are already created by that time
<Bike>
what
<jmercouris>
like (defun funk (x) ...)
quazimodo has joined #lisp
EvW has quit [Ping timeout: 255 seconds]
<jmercouris>
phoe: I see
<phoe>
jmercouris: do you know how the REPL works?
<phoe>
and at which point what happens?
<Bike>
you sound very confused
<jmercouris>
phoe: No, not really
<Bike>
"assigning a symbol" and "variable value" are both kind of meaningless
<phoe>
jmercouris: then do figure that out.
<jmercouris>
I've only read PCL which wasn't very helpful
Inline has joined #lisp
<jmercouris>
I'm going cover to cover now on Gentle introduction to symbolic
<phoe>
at read-time, the string "(defun funk (x) ...)" gets turned into a list
<phoe>
the first element of that list is the symbol DEFUN that was not created, because it is already present in the CL package
<phoe>
the second element of that list is the symbol FUNK that is not standard, therefore it could have been created automatically at read-time
<phoe>
bla bla bla, and so on
<phoe>
so you get a data structure after read-time - a list containing symbols, lists, whatever else
<jmercouris>
phoe: so, FUNK is instantiated at read-time?
Guest97645 has quit [Ping timeout: 256 seconds]
<phoe>
jmercouris: the symbol? usually, yes
<jmercouris>
I see, so during run-time we are never evaluating new symbols?
<Bike>
you only create symbols at runtime if you have a call to cl:intern, or the like.
<jmercouris>
s/evaluating/instantiating
<phoe>
jmercouris: what do you mean, evaluating new symbols?
<phoe>
oh
<phoe>
what Bike said
<jmercouris>
Aha
<jmercouris>
that makes sense now
<phoe>
you have to explicitly call MAKE-SYMBOL, GENSYM, GENTEMP, INTERN and so on
<jmercouris>
old code that I wrote is starting to make sense to me
<phoe>
to create symbols at runtime
<jmercouris>
I really did not understand what I was doing...
<Bike>
if you have, say, (defun funk (x) x), the symbol X probably exists at runtime only for debugging reasons. The actual code doesn't need it.
<beach>
jmercouris: The function may not be pointed to by the symbol, and the symbol may not have a slot containing such a pointer.
<beach>
jmercouris: As long as your implementation answers correctly to (symbol-function <symbol>) it can do what it wants.
<jmercouris>
so basically what jackdaniel said right? the implementation has latitude to implement the "symbol class" however it likes
<jmercouris>
?
<Bike>
it's related to what jackdaniel said, yes.
<jackdaniel>
have you ever doubted me? ;-)
<jmercouris>
many times, yes :D
<jackdaniel>
yes, I encounter it often. probably the way I speak.
<Bike>
there is an API. the API says you can use symbol-function to get the function named by the symbol in the global environment. the API does not say anything at all about how this is accomplished
<Bike>
because that's not a matter for an interface
<jmercouris>
I see, thanks for the information
<beach>
jmercouris: And, in fact, in SICL, the association between function names and functions is stored in a first-class global environment. That way, this association can be different in different environments.
rippa has joined #lisp
mindCrime has joined #lisp
warweasle has joined #lisp
<jmercouris>
beach: what do you mean?
<jmercouris>
what kind of different environments?
<jmercouris>
like packages?
<beach>
No, not like that.
<phoe>
jmercouris: beach made a thing where you can have two different global environments. in each of these environments, you can DEFUN a function with the same name, but two different bodies.
<beach>
The Common Lisp HyperSpec mentions the "null lexical environment" also known as the "global environment".
<phoe>
So env1 can have (defun foo () 42) and env2 can have (defun foo () "forty two").
<jmercouris>
ah, so you can do this within the same image?
<phoe>
yep
<jmercouris>
what are some reasons you might want to do this?
<phoe>
multiuser systems
<beach>
jmercouris: In SICL, I generalized this idea so that these environments are represented by first-class objects, making it possible to have several simultaneous but different instances of global environments.
<jkordani_>
yea I've been wondering about this too
<jackdaniel>
the practical gist of it is being able to have two different versions of the same library
<phoe>
multiple library versions
<jmercouris>
ah wow, I didn't even think about that
<phoe>
disposable environments for compiling and building stuff and running pure-CL CI and other stuff
<jmercouris>
interesting
<beach>
jmercouris: Yes, multiple versions of a library, sandboxing, bootstrapping, cross compilation, etc, etc.
<jmercouris>
can you dump a single environment instead of the whole image?
<beach>
jmercouris: In SICL, I can't dump anything right now.
<Bike>
environments as modules is something i've been interested in, though.
<jmercouris>
oh, I see
<phoe>
but I think it would be possible
<jmercouris>
Bike: what are modules?
<phoe>
dump a Lisp image where env1 is the "global global" environment
<beach>
jmercouris: There is a lot of stuff in the literature about modules for Lisp-like languages. A module is similar to an environment in that it is a mapping from names to values, as opposed to a package which is a mapping from symbol names to symbols.
<jackdaniel>
jmercouris: it is not CL term; scheme has modules, eulisp has them as well.
<phoe>
this diagram seems to represent the list (EQUAL 3 5)
<jmercouris>
it is showing (equal 3 5)
<jmercouris>
yes
<beach>
jmercouris: It is one possible implementation of a symbol.
<jmercouris>
and it is saying that the car of the first element is the symbol equal which has 5 slots
<jmercouris>
and it doesn't have to be so
<jmercouris>
it could be literally anything
<phoe>
jmercouris: yep
<phoe>
how a symbol is implemented is an implementation detail
<jmercouris>
it needn't have a function pointer pointing to the function etc etc
<Bike>
i mean, it kind of depends. there's no technical guarantee that a cons has to have any slots either, it just needs to have an accessible car and cdr. but it's convenient to graph it like that.
<beach>
jmercouris: Correct. And in SICL, symbol-plist is not in the symbol either. That too is in the environment.
<jmercouris>
beach: interesting, this is a change to enable multiple environments?
<jackdaniel>
I like to think about symbols as of strings with strings attached (pardon the pun)
<Bike>
The basic thing to understand is that Lisp doesn't make any guarantees about pointers or whatever. It's just not part of the semantics
<jmercouris>
s/change/design decision
<phoe>
it's hard to learn Lisp if you can't ever reliably get any pointers
<beach>
jmercouris: Putting symbol-plist in the environment was natural once I decided to use first-class global environments.
* phoe
mic drop, goes to #lispcafe
<beach>
jmercouris: So in SICL, a symbol only stores its name and its package.
<jmercouris>
I see, that makes sense
<beach>
jmercouris: In fact, the definition is (defclass symbol (t) ((%name :initarg :name :accessor name) (%package :initarg :package :accessor package)) (:metaclass built-in-class))
<jmercouris>
ah so you are actually using a real class
<jmercouris>
so it needn't NOT be a real class
<beach>
The symbol class must exist.
<beach>
There is no such thing as a "real" or an "unreal" class.
<jmercouris>
well, earlier jackdaniel said that it may be whatever the implementation wants
<jmercouris>
let me find the quote
<beach>
It is not a standard class, because I use the metaclass built-in-class.
<beach>
But the class is very real, just like any other classes in Common Lisp.
<jmercouris>
"<jackdaniel> symbol is a built-in class
<jmercouris>
<jackdaniel> it means that it doesn't have to be a standard-class
<jmercouris>
"
<jmercouris>
sorry for the messed up quotes
<Bike>
what jackdaniel meant is that you can't do things with a built-in-class that you can do with a standard-class. for example you can't subclass it.
<Bike>
it's still a "real" class in the sense that there is an accessible class object.
<beach>
jmercouris: Try (class-of 'hello)
<jmercouris>
#<BUILT-IN-CLASS COMMON-LISP:SYMBOL>
<beach>
So it's very real.
<jmercouris>
maybe it is too soon to be thinking about this
<jmercouris>
I am only on chapter 3 :D
<beach>
jmercouris: Every Common Lisp object is an instance of some class.
<jmercouris>
page 119/587, a lot more to go
<beach>
... including symbols.
<jmercouris>
that I remember hearing people say
<jmercouris>
the meaning still isn't clear to me though
<jmercouris>
what is and is not an object
<jmercouris>
for example is 3 an object?
<jackdaniel>
I think you meant this quote: "< jackdaniel> built-in class means: we pretened it is a class, but in fact it is internal datatype with shoehoerned aspects allowing dispatch on it"
<beach>
jmercouris: Yes, of course.
<beach>
jmercouris: Try (class-of 3).
<jmercouris>
jackdaniel: that is the quote I was thinking of
mn3m has quit [Ping timeout: 260 seconds]
<Bike>
you don't need to think too hard about it.
<jmercouris>
even functions are objects, interesting
<jmercouris>
(class-of #'class-of)
<jmercouris>
that I did not expect
<jackdaniel>
my point was to emphasize that some parts of "everything is a class" is very artificial to keep the model consistent (especially when we talk about built-in classes). but now I regret I've shared that opinion (because it seems to bring a lot of confusion)
mn3m has joined #lisp
<beach>
jmercouris: What did you expect instead?
<jmercouris>
I expected some internal data structure, something else
<jmercouris>
I should stop thinking about other programming languages
<beach>
jmercouris: You really really need to start thinking in terms of protocols (or APIs if you want).
<jmercouris>
well, not in general, but in this context
<beach>
jmercouris: There is a Common Lisp function called CLASS-OF.
<beach>
jmercouris: Its purpose in life is to return a class, which is a Common Lisp object.
<jmercouris>
which is an instance of #<SB-PCL:SYSTEM-CLASS COMMON-LISP:FUNCTION> on my implementation
<beach>
jmercouris: That can't be altered.
<phoe>
jmercouris: correct
<jmercouris>
who is the one who instantiates this object?
<phoe>
the symbol CL:FUNCTION names a class in Lisp
cgay_ has quit [Ping timeout: 276 seconds]
<phoe>
jmercouris: the implementation
<beach>
jmercouris: So you should not expect any other kind of object to be returned.
<jmercouris>
I see
<xificurC>
I think he has a chicken-egg problem
<phoe>
jmercouris: the implementation creates instances of that class for you when you, for instance, (lambda () 42)
<phoe>
this form evaluates to an instance of class FUNCTION
<xificurC>
I'm reading AMOP and haven't got a clue yet how are the metaobjects bootstrapped
<jmercouris>
is lambda itself not a function which returns a function?
<phoe>
jmercouris: no
<beach>
xificurC: That depends on the implementation.
<phoe>
(lambda () 42) expands into #'(lambda () 42)
<phoe>
and #'(lambda () 42) is (function (lambda () 42))
<phoe>
and FUNCTION is a special operator
<phoe>
that does the heavy lifting here
<jmercouris>
function is a function which creates an instance of the function class?
<phoe>
it grabs the LAMBDA *form* and returns an instance of a function based on the contents of that form
<phoe>
NO
<phoe>
FUNCTION is a special operator.
<phoe>
it is NOT a function.
<beach>
xificurC: In most implementations, that bootstrapping process is very messy, either for historical reasons or because the system is built in a different programming language.
<jackdaniel>
jmercouris: it lambda essentially creates a function. since "everyting has a class" in common lisp, such function is an object of a certain built-in class
<dlowe>
jmercouris: it doesn't follow function or macro application rules
<phoe>
dlowe: actually it follows macro application rules
<phoe>
since every specop is permitted to be implemented as a macro
kajo has joined #lisp
<jmercouris>
jackdaniel: so, lambda makes an instance of the function class? or did I misread?
<jackdaniel>
there is not much more into it, the only practical aspect is that you may specialize method on its class
<phoe>
jmercouris: it's a bit more complicated
<phoe>
the special operator FUNCTION grabs things and returns functions based on these things
<jmercouris>
maybe I should finish this book before going deeper into this
<phoe>
these things may be symbols or Lisp data
<jmercouris>
my head is already full of too many things to remember at once
<phoe>
and this Lisp data must be a list whose first element is the symbol LAMBDA
<xificurC>
jmercouris: what are you reading
<phoe>
so (function (lambda () 42)) is an example
<beach>
xificurC: In SICL, on the other hand, I use ordinary forms like DEFCLASS, DEFGENERIC, and DEFMETHOD to create this entire hierarchy: http://metamodular.com/CLOS-MOP/graph.png
<jackdaniel>
as I said, some "closiphology" is artificial. function is a function. to keep model consistent each function has a class associated with it
<jmercouris>
xificurC: I'm read Common LISP: A Gentle Introduction to Symbolic Computation, already read PCL, did a bunch of lisp programming
<beach>
xificurC: I can do that because I bootstrap using a full Common Lisp implementation, and I use first-class global environments.
<jmercouris>
now I'm hoping to start understanding more
<phoe>
beach: I want to see the place where you go (defclass t ...)
EvW has joined #lisp
<shka>
jackdaniel: well, or a funcallable object
<jmercouris>
phoe: you could just rgrep sicl, it is on github after all :D
<phoe>
jmercouris: oh right
<jackdaniel>
shka: sure, confuse him more. in the meantime I'll grab some tea
attila_lendvai has quit [Read error: Connection reset by peer]
<shka>
phoe: retard-oriented
fkac has quit [Read error: No route to host]
fkac has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fkac has quit [Remote host closed the connection]
fkac has joined #lisp
<makomo>
xificurC: you're reading AMOP? that's the next one on my lisp reading list :-D
<makomo>
you've probably seen it already, but appendix c deals with some of the circularities/bootstrapping problems
<phoe>
shka: beach: you both are right, I just wanted to write it for the sake of writing it. :D
<makomo>
the circularities that arise in reflective systems are really interesting
<beach>
phoe: Fair enough.
<xificurC>
makomo: yeah, not sure if I'm gonna finish the book though as I haven't done much CLOS in order to fully understand and appreciate what lies underneath it
<makomo>
also, i realized yesterday that 3-lisp was the author's phd thesis and the first formalization of the concept of reflection
<makomo>
and it's 700+ pages long
<makomo>
beautiful
<makomo>
xificurC: i see
<makomo>
i've heard that sonya keene's clos book is a good introduction to clos itself. what do others think of it?
jmercouris has quit [Remote host closed the connection]
attila_lendvai has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 264 seconds]
habamax has quit [Read error: Connection reset by peer]
subroot has joined #lisp
<beach>
makomo: I didn't like it much.
fikka has joined #lisp
<beach>
makomo: Probably because it used examples that I either could not appreciate, or that required non-standard functionality.
<beach>
makomo: One example was software distribution for different platforms.
<beach>
makomo: The other one required threads.
<beach>
makomo: Maybe I would like it better if I were to re-read it today.
<phoe>
Xach: I'd like to ping you for any news regarding Quicklisp
<beach>
makomo: If I were to write a book like that, I would probably use more mundane examples like people, companies, employees, countries, etc.
<makomo>
beach: that's something that i wanted to comment on. aren't such examples better than the washed-out examples of animals, shapes, etc.?
<makomo>
i've seen one review where someone says that the book does actually go over the canonical animal/shape example, but that there are actual "industrial" examples afterwards
<beach>
Maybe. I just didn't appreciate those particular choices.
<makomo>
to me that seems like something that's always missing from these OO introductions
fikka has quit [Ping timeout: 260 seconds]
<makomo>
it's always just simple and "dumb" stuff. i don't know how i feel about it.
<beach>
I was thinking of using an information system as an example.
<beach>
I don't consider that "dumb". It's a real application.
<makomo>
yeah, i don't think i do either, but i also don't recall ever seeing such a thing used in an OO introduction
<makomo>
but i guess that would also depend on have elaborate the system is
<makomo>
how*
<beach>
Indeed.
<beach>
But yeah, one has to avoid silly stuff such as (defclass student (person) ...).
<beach>
[as if a person is always going to be a student]
<phoe>
beach: actually a student is always going to be a person
<phoe>
I've yet to see a nonhuman student
<beach>
I mean, as if a person who happens to be a student is always going to remain a student and has always been one.
<phoe>
beach: oooh, right.
<makomo>
hmm good example
<makomo>
sometimes it just seems to me that more elaborate examples would be much better than the usual "we'll skip this, because it would take too much time" or w/e the usual "excuse" is
<beach>
I think that's the error in most books. They make class hierarchies that would absolutely not work in a real application.
<makomo>
actually working through a complicated example would help a lot
pierpal has quit [Quit: Poof]
<beach>
I guess that *is* an advantage of Keene's book. The examples are real, from real situations.
pierpal has joined #lisp
fikka has joined #lisp
<makomo>
mhm. i guess i'll give it a go
nika_ has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<makomo>
beach: do you plan on SICL supporting stuff like threads and other usual extensions? even if you don't, how would you go about implementing these since SICL is implemented in CL?
<Bike>
how can i make asdf use a given registry configuration file?
<makomo>
it might not matter that it is implemented in CL, as you said before (and the same thing goes for the LOOP macro that you implemented in CL), but if you for example relied on SBCL's threads or FFI how would you ever get rid of that dependency once you've bootstrapped
<makomo>
maybe i'm thinking about it in the wrong way, i don't know
<beach>
makomo: I definitely want to support threads and such.
<beach>
makomo: I would just make sure there is a bunch of functions that interface to the system calls of the operating system.
<makomo>
or would there have to be a part written in C for example to interface with the platform you're running on?
<Bike>
guess i have to like, throw it in a config directory. ok
Arcaelyx_ is now known as Arcaelyx
<beach>
makomo: Each system call would likely require a few lines of assembler.
<makomo>
beach: that can't be done with pure CL though, right?
<makomo>
oh, you'd directly invoke syscalls? hmm
<beach>
Yes, that's the plan.
<makomo>
so you wouldn't use stuff like pthreads, etc.?
<beach>
I don't think so, no.
fikka has joined #lisp
<makomo>
huh, interesting. is there a short answer as to why you would do it like that?
Cymew has quit [Remote host closed the connection]
<beach>
makomo: As opposed to going through libc, you mean?
<makomo>
yeah
Cymew has joined #lisp
<beach>
makomo: Because SICL is the basis of a planned Lisp operating system, and that operating system will not have any libc.
<beach>
... nor a C compiler for that matter.
<makomo>
*gasp*
<makomo>
hmm
<makomo>
so you would basically roll your own implementation of threads? i guess that makes sense if you're writing your own OS
<phoe>
yep
<beach>
makomo: Well, for existing systems like Linux, I would obviously use the OS threads.
<beach>
makomo: But, yeah, I don't see any shortcut for the Lisp operating system.
<makomo>
aha, right. the lisp OS would be a separate project, but it would rely on SICL for most stuff i guess?
<phoe>
depends
<phoe>
a lot of stuff is already surprisingly similar
<beach>
SICL with first-class global environments would be the basis, since it would already be a multi-user Common Lisp system.
smurfrobot has joined #lisp
<random-nick>
why not have a macro for syscalls? glibc has a function that lets you call any linux syscall
<warweasle>
makomo: If someone makes a lisp os, they really should use the linux kernel for drivers. Even if they have to convert them to lisp.
<warweasle>
Otherwise, it won't run on much.
<Ukari>
how to difference betwwen (values) and nil?
fikka has quit [Ping timeout: 256 seconds]
<Ukari>
(values) returns no value
<beach>
random-nick: It is not as simple as that for Common Lisp. You have to define what kind of Common Lisp data structure will be used for the call that normally accepts C structures, and then translate.
<Bike>
Ukari: "no values" is implicitly turned into NIL anywhere expecting one value,which is basically everywhere
<beach>
Ukari: You can distinguish them by using MULTIPLE-VALUE-LIST.
<Bike>
Ukari: one exception is you can do (multiple-value-list (values)) => NIL versus (multiple-value-list nil) => (nil)
kajo has quit [Ping timeout: 265 seconds]
<Bike>
okay, asdf config files don't follow links for the case of :here i guess
<makomo>
beach: and the point that warweasle makes about portability? is writing a whole kernel and all the different device drivers something that's part of the plan for the lisp os or?
<Ukari>
use length is a good idea, thank you
igemnace has joined #lisp
<random-nick>
beach: well, wouldn't that be handled using the FFI?
<phoe>
makomo: the device layer is actually separable from the actual Lisp implementation
<phoe>
random-nick: what FFI?
Cymew has quit [Ping timeout: 260 seconds]
<phoe>
there's no C libraries to speak of if there is no OS underneath
<random-nick>
there's the kernel to speak to
<phoe>
random-nick: there's no kernel underneath to speak of if there's no OS underneath
<warweasle>
I could see using lisp as the root process. ( init.d )
<Bike>
it's really incredible how annoying it is to tell asdf where to get files. no wonder central registry is still around
<makomo>
that's what my question is. is the planned lisp os going to reuse the linux kernel or create its own
<beach>
makomo: Contrary to other people, I consider the "running on bare metal" to be less important, but a cute thing, of course. I would be happy to run it in a Linux process to start with.
<makomo>
and if the answer is the latter, isn't that a huge undertaking and something one wouldn't really want to do
<random-nick>
phoe: I'm talking about running on existing systems
<beach>
makomo: Also, people assume that I want this thing to be widely used. That would be great but I doubt it will happen.
<beach>
makomo: I am a researcher. I just want to show that we can do better than what we are currently doing, and what we have been doing in the past. But I don't have great hopes that many people will be bother.
<phoe>
random-nick: yep, I see
<random-nick>
and talking to a kernel like Linux requires most of the difficult parts of a FFI
fikka has joined #lisp
<random-nick>
since some syscalls take pointers to structures
<random-nick>
and character arrays too
<beach>
random-nick: I am not terribly interested in FFI.
<warweasle>
Although, after learning forth, it sort of reminds me of forth.
<beach>
I think it would be a great exercise to see whether CLOS could be used to create a better hierarchy of device drivers than what C would allow.
brendyn has quit [Quit: WeeChat 2.1]
<warweasle>
beach: I don't think we can optimize much further without sacrificing security.
<beach>
Such a hierarchy *might* take some inspiration from I/O Kit, but not too much, of course.
<makomo>
beach: so in the context of SICL running as a linux process, supporting threads within such an implementation would require calling into libc right? how would that be done if SICL is written using CL?
brendyn has joined #lisp
<beach>
warweasle: Oh, I am not talking about speed. I am talking about maintainability and, yes, security.
pierpal has quit [Quit: Poof]
<warweasle>
Ah...I assumed you wanted to compile and optimize the entire driver stack.
<makomo>
warweasle: interesting. i heard something similar a while ago, something about recompiling the code of the filesystem i think?
<beach>
makomo: No, it would be done by doing system calls directly.
pierpal has joined #lisp
<beach>
warweasle: I would like to see whether it could be advantageous to use CLOS to write such a collection of drivers.
<warweasle>
beach: Object Oriented doesn't seem to make good kernels or drivers.
<makomo>
beach: ok, but i think the question of "how would it be done within CL?" still stands. how would you connect assembler and CL?
<beach>
warweasle: I think you are totally wrong about that.
<warweasle>
Have you heard of Herd?
<random-nick>
you mean Hurd?
<Bike>
the first research paper i ever read was an operating system based on having objects with jit compiled methods for syscalls. that was neat
<beach>
makomo: There is always a little machine code or "assembler" in a complex system like Common Lisp. The code generator of a compiler for instance. And there would have to be a few lines of such assembler to implement a Common Lisp function such as POSIX:OPEN.
<Bike>
it was in the 90s though and didn't exactly catch on, so
<warweasle>
beach: The problem is OO requires the language or runtime to do things for you. In kernel space you don't have that luxury. If you take the runtime away, you just have structures.
<warweasle>
Bike: Is that the same one I posted?
<beach>
warweasle: Are you talking about a typical Linux-like kernel or about a new LispOS kernel?
fikka has joined #lisp
<warweasle>
Kernels in general.
<on_ion>
the cpu and i/o controllers and all the devices need software help
<beach>
warweasle: Because the Lisp OS I am planning won't even HAVE a kernel.
<warweasle>
beach: Have you heard of OSKit?
<beach>
warweasle: So I can use full object-orientation in system code.
<beach>
warweasle: I have, but it was some time ago.
<beach>
warweasle: Most projects like that assume that you are writing a Unix-like kernel.
<on_ion>
we are running countless OSs in virtual machines, virtualbox or qemu etc, why not just accept SBCL or emacs et.al for another VM? why a bare metal machine OS?
<warweasle>
on_ion: Good point.
<beach>
warweasle: HURD is the exact opposite of what I want.
<warweasle>
It's a microkernel. That didn't seem to work out. I don't believe smaller will make it work any better. There has to be communication between pieces. And then you have a kernel again.
<random-nick>
beach: so would your LispOS look something like TempleOS?
<random-nick>
I mean architecturally, not the religious elements
<warweasle>
You *could* implement lisp on top of forth and get something like you are thinking, but it's a very bare os.
<on_ion>
like they designed an implementation where the pieces cannot talk, warweasle ? =) there was just not that many people working on HURD
<phoe>
random-nick: AFAIK yes, except the user normally does not have raw access to memory like in TempleOS
fikka has quit [Ping timeout: 260 seconds]
<beach>
warweasle: You seem to be assuming a traditional OS with separate processes for each running program, requiring address remappings and hence communication by copying bytes between kernel and applications.
<on_ion>
people have been writing some interesting software for TempleOS. build it and they will come
<warweasle>
beach: How can I not? Unless it's a single application in a single thread.
<beach>
warweasle: Instead think Genera, but with safety and multi-user environment.
<on_ion>
the channel topic is getting more out of date by the second
<random-nick>
phoe: well, I guess that's a consequence of HolyC's design
<warweasle>
beach: What enforces the safety?
<phoe>
warweasle: lack of API (:
<random-nick>
but user code would still be able to access all of the system's objects, right?
<on_ion>
we can run genera in a VM too, warweasle do you know much about it ?
<phoe>
random-nick: depends if these are objects are present in that code's global environment
<warweasle>
on_ion: No. I only know old school bare metal.
<warweasle>
Much else and my head hurts.
<beach>
warweasle: I think you need to read the design document. Otherwise, I am afraid I am going to end up re-typing it here in its entirety.
<makomo>
beach: i still don't understand how that would be done for a CL implementation written in CL. i'm ignoring the lisp OS thing for a now and focusing just on SICL being a CL implementation that i can run for example on linux. how would it implement these syscalls if it only has CL to work with? would you use some non-standard stuff from SBCL? would part of it be implemented in C or assembler? how would it work?
<phoe>
makomo: if you have a Linux beneath, you need to communicate with it
lumm has quit [Remote host closed the connection]
<on_ion>
warweasle: beach mentioned it is like Genera, but with safety and multi-user environment. if you dont know genera, how to continue the conversation ? i point this out because edging close to misunderstandings or misinterpreted idea[l]s
shka_ has joined #lisp
<phoe>
the basic means of communicating with it is executing the interrupt 0x80 CPU instruction
lumm has joined #lisp
drastik__ has joined #lisp
<beach>
makomo: SICL is (going to be) bootstrapped on a Common Lisp implementation. An executable file will be created. That file contains machine code. Some of that machine code will be the implementation of the function POSIX:OPEN. During bootstrapping, that function will be defined to execute the machine instruction for making a system call. That's all it takes.
<phoe>
which is the part of the libc syscall() instruction that actually passes control out of the process and into Linux.
<phoe>
either you link against linux's libc that contains syscall() and you call it, or you reimplement its functionality in whatever you want and then interrupt the OS manually.
flamebeard has quit []
fkac has quit [Remote host closed the connection]
<phoe>
if you want no LIBC linkage, that is possible.
<warweasle>
on_ion: Basic OS theory shouldn't change. What I hear is "DOS running lisp"
fikka has joined #lisp
<makomo>
beach: oh hmm. so the creation of this executable will be part of the bootstrapping process?
<random-nick>
warweasle: what's wrong with that?
<phoe>
warweasle: there's no DOS in there
<beach>
warweasle: Unfortunately, most of the OS literature also assumes a Unix-like kernel. A better thing to look at would be Multics. And of course, Genera.
<random-nick>
lisp is far more suitable to be the only language compared to machine code
<beach>
makomo: Yes.
<phoe>
DOS is actually nice enough to allow you to erase it from memory and replace with anything else you'd like
<beach>
warweasle: So it is very likely that, despite your having read most of the existing OS literature, they haven't told you everything.
drastik has quit [Ping timeout: 276 seconds]
<phoe>
so there's no DOS in "DOS running Lisp"
<warweasle>
Ok, I don't get it.
<beach>
Sorry to hear that.
thodg has quit [Ping timeout: 255 seconds]
<flip214>
phoe: so is windows, if you have a way to run code in kernel space.... ;)
fikka has quit [Ping timeout: 256 seconds]
<warweasle>
It seems a lot like running lisp as your shell.
<phoe>
flip214: you know how the saying goes: if all you have is a DOS, everything looks like kernel space (:
robotoad has joined #lisp
<warweasle>
If all you have is DOS, you are still better off than Window 95.
<warweasle>
Windows 3.1 was ok.
<random-nick>
are you sure? 95 added long filename support
<loke>
warweasle: Windows 3.1 was _not_ OK. I firmly believe you are wearing rose-coloured hindsight glasses.
<random-nick>
also, 95 was a 32-bit OS
<warweasle>
Maybe, it was my first graphical shell.
<shka_>
so much of topic
<dlowe>
yes, the long filename SUPPO~1
<phoe>
welp
<warweasle>
DOS could be 32 bit! You just had to make a few BIOS calls.
<loke>
random-nick: W95 still had 16-bit DOS drivers (in many cases)
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<warweasle>
Then get into a flat memory mode.
<warweasle>
And tell MASM which parts of the code were which.
<warweasle>
Maybe I just have Stockholm syndrome.
fikka has joined #lisp
<beach>
warweasle: Anyway, I am sorry that I am unable to communicate the essence of my ideas to you. Maybe in the future, I can improve my communication skills, probably in the form of more written documentation.
<warweasle>
So classes are really just metadata for a compiled procedural code?
<warweasle>
for = on top of
<on_ion>
what classes?
drastik__ has quit [Ping timeout: 260 seconds]
<warweasle>
In genera.
<on_ion>
ah oops sry
<phoe>
warweasle: classes are objects describing other objects
attila_lendvai has quit [Quit: Leaving.]
<on_ion>
lisp interpreted is like a genera, really; we just have more stuff on the "outside" of it, like device drivers, network management, etc.,
<phoe>
in particular, instances of classes have slots, which contain data
<on_ion>
interpreter** like SBCL, emacs, etc
<phoe>
if anything, generic functions are metadata for compiled procedural code
<phoe>
metadata in the broad meaning of the word
<warweasle>
I'm curious about vtables. Vtables in low level drivers are difficult. Especially when you can't control their lifetime and memory management directly.
<random-nick>
aren't vtables a C++ thing?
<phoe>
warweasle: depends on whether your low level driver needs a vtable
<beach>
on_ion: Whether it is an interpreter or a compiler is not important.
light2yellow has joined #lisp
<phoe>
your driver can be a Lisp function that grabs (fdefinition 'network-driver:do-some-stuff) and calls the resulting function object
<phoe>
there, no vtable, there's just a global environment that you query
<beach>
warweasle: CLOS typically does not use vtables for its implementation, in case you are referring to the kind of vtables often used to implement C++.
<warweasle>
So it would be like running lisp from DOS. It does everything including overwriting the interupt calls.
<phoe>
warweasle: again, running Lisp from DOS isn't very different from running Lisp without any underlying OS
<Bike>
warweasle: oh, synthesis, yes.i didn't see your link.
zotan has quit [Ping timeout: 240 seconds]
d4ryus has joined #lisp
<phoe>
the way you do low-level stuff doesn't really differ from the way you do high-level stuff in Lisp
<warweasle>
beach: How does it manually manage memory and resources in a garbage collected environment? Is it a separate interface?
<random-nick>
I still think that a lispos shares more similarities with TempleOS' architecture than with DOS'
<loke>
random-nick: Or you could argue that templeos borrows from Lispos :-)
<loke>
I'm pretty sure Genera is older :-)
<warweasle>
Don't get me wrong, I love lisp. I just don't see how it can be used at the embedded level.
<beach>
warweasle: What is "it" and why would it need to manually manage memory?
<warweasle>
Something has to assign memory and then free it.
<phoe>
warweasle: if you need some memory never to be released then you simply tell the GC that it should never free that thing
johnvonneumann has joined #lisp
johnvonneumann is now known as Guest8344
<phoe>
for example pin in it the active global environment: (defvar *very-important-device-something* ...)
skapata has joined #lisp
<phoe>
as long as the environment lives, the value of that variable lives
<beach>
random-nick: Yes, TempleOS has some of the features of the LispOS I am planning.
<beach>
warweasle: Yes, it is called the memory manager, of which the garbage collector is an essential part.
fikka has joined #lisp
<warweasle>
So you have something simlar to (make-interupt-handler irq 0x8080 code...)
<beach>
Looks about right.
<warweasle>
And the "class information" is not kept inside the code but rather outside it as "metadata".
<beach>
?
<phoe>
warweasle: what do you mean by class information?
<warweasle>
You don't have the interupt looking up the code to call. It just calls the compiled code directly.
<phoe>
oh right
schweers has quit [Remote host closed the connection]
<beach>
warweasle: You would very likely need a few lines of machine code to trampoline to a Common Lisp function.
<warweasle>
And you just have to be careful to make short, fast interupt routines.
<phoe>
there's no problem with creating a Lisp instance INTERRUPT-HANDLER, putting a reference to it inside some INTERRUPT-HANDLER-TABLE instance, and then call some function #'INSTALL-INTERRUPT-HANDLER-TABLE on that instance
<warweasle>
beach: About that...Even in C you don't have time to do any processing. You just post a message to act on later.
fikka has quit [Ping timeout: 260 seconds]
<warweasle>
I would seem like you could easily take too much time doing that many lookups.
<beach>
That could easily happen. In which case it would have to be fixed.
<phoe>
warweasle: well
<phoe>
#'INSTALL-INTERRUPT-HANDLER-TABLE could just as well compile that instance into an actual fixed jump table, so a bunch of JMPs in memory
bugrum has joined #lisp
<warweasle>
But it's all lisp all the way down but without the typical protection lisp give you.
<phoe>
warweasle: define "without the typical protection"
<random-nick>
what do you mean by "the typical protection"?
bugrum has quit [Client Quit]
<warweasle>
Memory management, garbage collection, thread protection, etc. At least at the low level.
<phoe>
warweasle: there's never any protection on the low level
<warweasle>
Swapping out function calls as you change the functions...
<phoe>
if there was, *nix kernel panics wouldn't be so fatal
<on_ion>
beach: i meant implementation, sorry.
bugrum has joined #lisp
<phoe>
except Lisp gives you some more things like a sane type system that helps you actually not commit a crashing mistake
<on_ion>
i was not referring to compiler v. interpreter, not part of current context of topic, but implementation v. implmntation
<on_ion>
whether it be LispOS or genera or this VM or that VM
<phoe>
warweasle: also "Swapping out function calls as you change the functions" is already being done in implementations
<warweasle>
phoe: At the interupt level?
<phoe>
warweasle: nope :P we have no such low-level Lisps
<phoe>
but redefining functions at runtime already happens well enough in multithreaded implementations
EvW has quit [Ping timeout: 260 seconds]
<warweasle>
OK...now I'm tracking. It's almost like having two lisps, a high level and low level.
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<phoe>
except they're actually one lisp
fikka has joined #lisp
<warweasle>
One compiler. Different levels of protection/access/etc
<phoe>
warweasle: oh yes, that's correct
<phoe>
the standard user should not have direct access to memory
<warweasle>
So there *is* a kernel of sorts.
<warweasle>
Now it fits in my mental model.
<phoe>
warweasle: for protection/access? doesn't have to be
<phoe>
the best way of not having direct acccess to memory is not having direct access to memory
<random-nick>
no, it's more like everything is the kernel
<beach>
warweasle: Just as in Common Lisp, you can't access an arbitrary byte of memory, you couldn't do it in the LispOS I am planning either.
<beach>
warweasle: But it is not because there is a kernel. It is because you are simply not allowed to write code that accesses memory directly.
<phoe>
if your Lisp REPL does not give you access to any stuff like dereference-pointer or such, you simply can't do it
<phoe>
it's hard to dereference a pointer if there's no pointer and there's no dereferencing API
<phoe>
...this sounds like some hardcore zen stuff
<warweasle>
What about hardware memory mapping?
<phoe>
ha, actually beach got that one covered in his paper
<warweasle>
I can't find the paper, just code.
<phoe>
AFAIR he wants to use RAM as a cache for hard drive space
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
EvW has joined #lisp
<Bike>
does anyone actually understand asdf congiruations
<beach>
Maybe Fare.
<phoe>
Bike: anyone as in anyone in the world?
<phoe>
Bike: that might not be a trivial question to answer
<Bike>
central registry it is
<nirved>
beach: what about LispOS and different accelerators, i.e. GPUs?
<beach>
nirved: I haven't thought about that at all. Sorry.
<beach>
nirved: But maybe you have a more specific question?
<beach>
nirved: Again, I seriously doubt that it would be widely adopted. I am a researcher, and I want to show that we can do better than we have been doing for the past half a century or so. If Nvidia does not buy that, then there is nothing I can do about it. As long as I can show that IF NVIDIA HAD ACCEPTED IT, then we would be better off, I am satisfied.
<beach>
nirved: Does that answer your question?
arubin has joined #lisp
vibs29 has quit [Ping timeout: 256 seconds]
pierpal has quit [Ping timeout: 248 seconds]
robotoad has quit [Read error: Connection reset by peer]
<beach>
nirved: I am one single person, and I can't possibly rewrite all the applications I use on a daily basis in Common Lisp so that I can ditch my GNU/Linux system. So for the foreseeable future, I would have to use both systems simultaneously. One way to do that is to run the LispOS as a Linux process. Another possibility would be to run it in some virtualizer.
robotoad has joined #lisp
vibs29 has joined #lisp
<nirved>
beach: i mean, will there be a way to extend it, supporting different kind of devices
<nirved>
since you mentioned no raw memory access
<phoe>
nirved: as the user? will be hard
<warweasle>
beach: I might have to write embedded code in the future. So that's why I'm asking so many questions.
<phoe>
as the implementer? should be possible
<beach>
Because of first-class global environments, there could very well be one environment, inaccessible to the ordinary user (would require "system" privileges) that would be able to access memory directly.
<beach>
But that functionality would not be accessible to ordinary users in "user" mode. All of that is totally unimportant for the overall safety of the system. It still has nothing to do with a kernel. Such a privileged environment might also be
<beach>
warweasle: I don't think you would want this system for embedded code.
<warweasle>
But parts of it might be useful. You never know what might give you an idea that simplifies a project immensely.
<beach>
... might also be used for compiler-backend stuff that should not be accessible to the application programmer.
<on_ion>
hey guys this doesnt look like common lisp
<warweasle>
*IF* I could bootstrap an implementation of lisp onto the machine, then I might have a lot of fun poking the device.
<beach>
nirved: But that's not what I am planning for SICL, etc.
<beach>
nirved: But GC is very complicated in terms of predicting performance, so it's too early to determine whether my plan will work out.
smurfrobot has quit [Read error: Connection reset by peer]
<beach>
warweasle: And it would be safer and easier than if you do it with (invalid) C.
smurfrobot has joined #lisp
fikka has joined #lisp
<beach>
on_ion: Are you saying this discussion is off topic?
<on_ion>
beach: nope sorry, just wondering if this was all common lisp, which would need a lot more than bare metal core runtime
<jackdaniel>
if we insist it is CL-only channel (not lisp-in-general-related-channel), then it might be a case
<on_ion>
ie. if the hardware was lisp
<on_ion>
idk if its #lisp or ##lisp that is CL-only, to me it doesnt matter
<beach>
jackdaniel: Well, we do talk a lot about FFI here.
<dlowe>
my take was that beach was talking about common lisp
<beach>
I was, yes.
<random-nick>
well, it's common lisp if it implements the standard...
<on_ion>
i mean it matters but i go with the flow of whatever people are talking about
<dlowe>
it's in the topic
fikka has quit [Ping timeout: 240 seconds]
<dlowe>
on both #lisp and ##lisp
<jackdaniel>
beach: ffi is part of *existing* implementations, but whatever. if people around are happy I have nothing against. just dropped my 2 cents
<on_ion>
a lisp OS would have a lot of boilerplate to hoist the CL system then
<beach>
jackdaniel: Got it.
<dlowe>
on_ion: why?
<beach>
on_ion: Bootstrapping a Common Lisp system is an interesting topic.
<on_ion>
dlowe: well, wait are you really asking? how could someone run CL without a CL implementation ?
<on_ion>
dlowe: like said, unless the hardware is lisp
<dlowe>
on_ion: we have CL compilers that produce machine code.
<beach>
on_ion: You would build an executable on a different system with an existing Common Lisp implementation.
<on_ion>
yes but, you still need that CL implementation alive and kicking to have a lisp system, no?
<beach>
Only to create the executable.
<beach>
Then you would have your own Common Lisp system.
<on_ion>
oh, so its just an OS written in lisp, but not providing a CL system ?
<random-nick>
why not?
<beach>
No, no, it *IS* a Common Lisp implementation.
<on_ion>
if you bootstrap another CL system its still a requirement of having a CL system
<on_ion>
beach: right =)
<jackdaniel>
on_ion: same comes to any program (except ones writtenn in hand machine code) – you need kicking C compiler to build C compiler (or Linux kernel)
<random-nick>
there are already CL implementations like SBCL and CMUCL that bootstrap from an existing implementation
<White_Flame>
if you need an x86-hosted C compiler to generate an ARM program, does that mean the program has a requirement of x86? not really
<on_ion>
jackdaniel: a CL system requires the full CL system to be a CL system, no? C executables dont need C compilers
<on_ion>
ie. runtime
pierpal has joined #lisp
<warweasle>
beach: Your "file system" looks alot like my QIX system.
<beach>
warweasle: That's good I guess.
<on_ion>
a running lisp system needs a living lisp VM and all the things, no? am i missing something?
<on_ion>
otherwise what is the point of a lisp os?
<Bike>
C executables usually need a C runtime
<White_Flame>
and C needs a runtime, and Forth needs its software stacks, etc etc
<Bike>
that is, libc
<on_ion>
yes Bike
<warweasle>
No monolithic files but you can link to s-exps from other s-exps.
<jackdaniel>
on_ion: I said that you need C compiler to build C compiler for a new platform for that instance. I think you are a bit confused with a few different (though slightly related) topics
<Bike>
beach is certainly not planning on anything that could be called "minimal" :)
<on_ion>
i am saying that a CL os/kernel needs at bare minimum, a CL implementation.
<Bike>
probably
<beach>
on_ion: Of course, yes.
<warweasle>
beach: But I used them to keep change logs and to remotely access them using UUIDs.
<on_ion>
whereas a C os just needs the C runtime (except the loewr level parts ofc)
<beach>
warweasle: I see.
<on_ion>
beach: ok, ty
<White_Flame>
it all depends on what you mean by "implementation"
<White_Flame>
a deployed CL kernel might not have a compiler, or whatever
<Bike>
i mean you could have a lisp runtime, like how ECL has libecl
<random-nick>
no, a CL implementation only need the things specified in the CL standard
fikka has joined #lisp
<random-nick>
it's can still be a CL implementation if it runs on bare metal
<warweasle>
beach: Sort of a "self describing" data, but with a few basic interfaces for text, rich text, image, vector, sound, etc.
<beach>
Interesting.
<on_ion>
so if one gets CL running on the bare, that is a good start
<beach>
on_ion: Oh, that one is easy and has been done twice.
<jackdaniel>
on_ion: #mezzano runs on bare metal, movitz did (does?) too
<beach>
Movitz and Mezzano.
<on_ion>
ok =) what is wrong with those ?
stacksmith has quit [Ping timeout: 245 seconds]
eminhi has quit [Quit: leaving]
EvW has quit [Ping timeout: 240 seconds]
<beach>
on_ion: They have no protection to speak of, and they are not multi-user.
<on_ion>
even if one could gut out the things one does not want/need, to get CL running on bare, and work on one's own OS ideas from there
<beach>
on_ion: And I believe they plan to use an ordinary file system for Mezzano.
<jackdaniel>
different goals and everybody likes to tinker with his own thing
<on_ion>
beach: but we can code that stuff?
<on_ion>
is there a plain/vanilla bare-metal CL implementation that all the OS experiments could use ?
<beach>
on_ion: I don't think it can be added on top.
<bugrum>
on_ion: I was under the impression that was what Movitz attempted to do
<on_ion>
beach: if one strips out everything but the CL implementation bits
<jackdaniel>
fun fact: froggey created llvm->CL transpiler
<beach>
on_ion: I would much rather start with a Common Lisp system NOT running on bare metal but that I can run with proper debugging support, etc.
<on_ion>
beach: true, im not knowledgeable in their abilities. i know that NASA had some lisp thing going on with a rocket which definately was bare metal
fikka has quit [Ping timeout: 265 seconds]
brandonz has quit [Quit: WeeChat 2.0.1]
<on_ion>
will the OS only accept CL code? ie. fasl?
<on_ion>
(asking because of jackdaniel 's link)
<White_Flame>
what does does Windows accept?
pjb has joined #lisp
<White_Flame>
OSes generally "accept" a binary footprint of machine code & data with start address & links to system stuff
<random-nick>
on_ion: why would that matter? lisp is turing complete
<on_ion>
native code wrapped in a PZ thing basically
<White_Flame>
no matter the language
<White_Flame>
or, no mattter the high level language, to be specific
<on_ion>
White_Flame: yeah. so im just wondering why there is a llvm->CL transpiler if one cannot simply execute the llvm like on a regular OS
<White_Flame>
because lisp environments don't have a notion of "program" as a base concept
<on_ion>
im curious because beach mentioned security also , which i am interpreting a bit like a CL sandbox
<on_ion>
so on a lispOS we would have to write everything as CL? (this is what i am asking.)
<White_Flame>
everything would have to compile down to whatever its base execution model is
babathreesixty has joined #lisp
<jackdaniel>
nothing prevents you from writing C compiler in CL
<White_Flame>
which is whatever it uses to generate machine code to its ABI
<jackdaniel>
I think there even was one, called vacietis
<White_Flame>
old lisp machines ran on stack machine hardware, iirc
<jackdaniel>
which compiled into an object on whom you could call main function
fikka has joined #lisp
<on_ion>
White_Flame: so kinda like fasl? a CL bytecode?
<White_Flame>
and there's nothing stopping webasm-style C execution footprints
<Bike>
I think beach's particular design doesn't really allow arbitrary binaries in the same way.
<White_Flame>
fasl is a file format, it's not the runtime ABI
fraya has joined #lisp
<on_ion>
fasl is what is emitted and loaded after sbcl compiles lisp, right ? same practical purpose as if it were a "CL bytecode" ?
<on_ion>
i dont know the tech details. just asking if a lisp OS would only execute lisp
<White_Flame>
it's roughly equivalent to loading source code
<White_Flame>
basically, what you're asking is the equivalent of running in random patterns in a vocabulary minefield ;)
<Bike>
sbcl fasl files contain machine code, not bytecode. but yes, it's the output when you compile a file.
<on_ion>
can it be "decompiled" back into source code ?
<White_Flame>
many many terms are used really out of their useful context
<on_ion>
ah hmm.
<akkad>
a fasl parser would be nice
<on_ion>
didnt know they were system-specific
<White_Flame>
fasls are very specific to implementation versions
fikka has quit [Ping timeout: 256 seconds]
<jackdaniel>
for instance ECL's "FASL" files are in fact shared objects (as *.so libraries) on Linux
<akkad>
and os, and isa
scymtym has quit [Read error: Connection reset by peer]
<on_ion>
aha, i see =)
<akkad>
but you can run fasls directly
<beach>
on_ion: Traditional code that uses the full address space would have to be run in a separate process, presenting itself as a single Common Lisp function.
<beach>
Such code could not directly access Common Lisp objects in the system, but they would have to use something similar to file descriptors. That would be just as inconvenient as it is on Unix systems now, so it would probably be uncommon.
<on_ion>
i really like the idea of the filesystem being "live objects" in the "image"
<froggey>
beach: no, I intend to use an in-image filesystem as the primary fs. there's a basic proof of concept already (the local filesystem), but I haven't really nailed down any details
<on_ion>
beach: ahh i see, cool =)
<beach>
froggey: Great!
<beach>
froggey: I just think I saw some work on vfat or something similar.
igemnace has quit [Remote host closed the connection]
<White_Flame>
froggey: in-image as in full single address space? :)
<beach>
froggey: I guess that could be useful for things like USB sticks.
skidd0 has joined #lisp
<froggey>
White_Flame: right
<White_Flame>
ooh nice
<beach>
froggey: So are you making good progress?
<White_Flame>
I haven't had the chance to use any true single addresses OSes yet
<froggey>
beach: yes, I think vfat was implemented to help the developer learn the system
<White_Flame>
*space
<beach>
Oh, I see.
<beach>
froggey: It would be great if you could plan to come to ELS in Genoa. We could chat about things like this.
<on_ion>
hmm Mezzano github page describes much emacs-style things...
<on_ion>
could it [theoretically or in future] run CLIM and second climacs ?
fikka has joined #lisp
<beach>
I think McCLIM already runs on Mezzano.
<on_ion>
ohhh =)
<froggey>
my current focus is getting the mezzano backend for mcclim into an acceptable state for demo 4
<skidd0>
Hey guys. I'm attempting to build a small command line program on Linux in Common Lisp. Does anyone have experience with distributing small lisp programs? And, any favorite libraries for handling command line args? There seems to be a lot of options out there for both questions, so, I'm looking for community input
<jackdaniel>
I'm afraid backend is not merged yet, but fittestbits did a great work with it
<beach>
Oh, OK.
<rpg>
skidd0: I have used buildapp successfully, which automates a lot of the hard parts.
<jackdaniel>
skidd0: check out clon (dider verna wrote it)
<on_ion>
how does it run Nethack? arbitrary binaries support?
<jackdaniel>
it provides great handling of the command line arguments
<jackdaniel>
and works on *many* implementations
<skidd0>
yeah i have CLON (and a few others) pulled up in Chrome atm
<White_Flame>
skidd0: I've deployed really small initialization utilities as standalone executables. They're obviously still laughably large in filesize for what they do, but it's nice to include all the libraries & lisp knowledge that the main application uses
<skidd0>
CLON looks the most straightforward
<froggey>
and yes, I'd like to attend ELS, but it's a bit too expensive for me
<beach>
froggey: That can be fixed.
<jackdaniel>
I've used clon in a few things and it worked great
<rpg>
skidd0: I have heard different things about how easy it is to move buildapp apps around. I believe that there can be issues with shared libraries when you move them, but I'm afraid I do not understand these issues myself\
<froggey>
on_ion: that's a bit of a cheat, it's telnetting to the nethack server on nethack.alt.org
<skidd0>
well so has anyone build 'apps' that are easy for other (non-lispers) to download and then execute/use?
mflem has joined #lisp
<jackdaniel>
rpg: basically when you dump sbcl image with foreign libraries loaded, it tries to load them from the very same location when you start the application
<jackdaniel>
so in order to avoid that you need to close all shared libraries before dumping image
<on_ion>
froggey: oh! nope thats cool =) most players play through telnet afaik ^_^
<jackdaniel>
and load them in main function at the beginning
<froggey>
I did write Iota to support some C programs (doom & quake run)
<rpg>
jackdaniel: I have never built anything with FFI that uses buildapp, so that shouldn't be a problem for me. I was wondering if there were any shared libraries that SBCL itself would load.
* beach
leaves to have dinner with his (admittedly small) family.
<froggey>
there's no support for running arbitrary native code though, everything must conform to the mezzano abi for the GC
<on_ion>
froggey: ah wonderful =) framebuffer?
fikka has quit [Ping timeout: 245 seconds]
<jackdaniel>
only those which you load yourself. the trick is that it assumes that libraries loaded when you dump image will be at the exactly same location
<froggey>
beach: fixed how? (when you get back)
<rpg>
jackdaniel: Thanks! That makes me feel better, because I haven't done that!
<froggey>
on_ion: yes, just basic framebuffer support right now. the video mode is set by the bootloader & not changed after that
<on_ion>
cool cool
<jackdaniel>
rpg: (of course that applies to the libraries your dependencies load). also there is a trick with cl+ssl – you need to call also "reload" function, because some structures must be initialized in the foreign library
<rpg>
jackdaniel: Ah. Thanks for the pointer!
fikka has joined #lisp
m00natic has quit [Read error: Connection reset by peer]
kajo has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<jackdaniel>
sure
fikka has joined #lisp
stacksmith has joined #lisp
thodg has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
<White_Flame>
skidd0: executables are executables
<White_Flame>
lisp really doesn't change much there
<White_Flame>
you need to figure out what sort of file structure it wants around it, or if it's purely self contained
<White_Flame>
and use the commonly expected installation procedures specific to your OS
housel has quit [Read error: Connection reset by peer]
_cosmonaut_ has quit [Ping timeout: 264 seconds]
<skidd0>
well so a sbcl save-and-die produces an executable
<skidd0>
and if i do that sbcl dave-lisp-and-die on my linux box
<skidd0>
can i share that produced executable?
<skidd0>
with other linux users?
<White_Flame>
um yeah, that's what an executable is ;)
<skidd0>
well sure
<White_Flame>
there's no system-intsalled runtime like java or C#
<dlowe>
there may be some oddities with shared libraries if you use some
<skidd0>
but do they need my distro?
<White_Flame>
that's not a lisp-specific issue
<skidd0>
the exe has the sbcl image in it's core, right?
<White_Flame>
yes
<skidd0>
okay
<White_Flame>
plus your changes
<White_Flame>
as the sbcl executable itself is a runtime core + image
<dlowe>
White_Flame: it kind of is, because our lisp systems don't use libdl to automatically link all the shared library code back up
<skidd0>
sorry, guys, i'm thrying to grok all this CS stuff my "higher-ed" never taught me
<White_Flame>
well it's mostly about Linux pragmatics, not really CS stuff
<dlowe>
no need to apologize. That's what we're here for.
<White_Flame>
and yeah, it's a more complex space than windows or osx might be for these particular points
<skidd0>
my understanding of executables is basically that they are black boxes
<dlowe>
they're just files.
<dlowe>
they have bytes in them.
<skidd0>
that are machine code?
<skidd0>
right?
<dlowe>
well, there's machine code in them
thodg has quit [Read error: Connection reset by peer]
<dlowe>
but generally it's more structured than that
<skidd0>
man the more i dig into programming, the more i realize how pointless paying tuition is
<dlowe>
there's some good resources on understanding the ELF format
fikka has joined #lisp
<dlowe>
it's not... entirely pointless
<skidd0>
do you have any?
<skidd0>
it gets you a nice peice of paper that tells the world you "know" things
<skidd0>
that they never taught you
<dlowe>
no, it lays intellectual foundations for later
<skidd0>
i thought that was High School
scymtym has joined #lisp
<White_Flame>
programming is still a craft. there's no major thread of academics that teaches it
varjag has joined #lisp
<dlowe>
I dropped out of college and when I compare my career with my programming peers that stuck with it, it was *much* harder for me. Those fundamentals are great to learn up front.
<White_Flame>
cs = the "science" of computation. ce = building hardware. software engineering = project management
<White_Flame>
nowhere in there are the actual good practices of effective programming
<skidd0>
i'm somputer security
<skidd0>
which means even less of the fundamentals
<dlowe>
oh, I don't have any experience with those.
<dlowe>
I was assuming CS
<skidd0>
well my interests are evenly split between CS and security
<White_Flame>
dlowe: yeah, I'm in the same boat (though I didn't willingly drop out; I got "financial aid"ed out of school :-P)
<skidd0>
but, i'm interested in your experience as a drop out vs your peers
<skidd0>
both of you, if you're willing to share
<dlowe>
White_Flame: fortunately, I'm old enough to precede the financial aid fiasco
<skidd0>
i'm looking at my last year of undergrad and i just can't bear the thought of it
<White_Flame>
dlowe: my university experience was in the mid 90s
<skidd0>
it makes me physically ill to think about, honestly
<dlowe>
skidd0: you should be talking to a dept advisor for advice, not IRC randos
<White_Flame>
the school didn't file my financial forms, and it went downhill from there :)
<dlowe>
they should give you resources
Myk267 has quit [Ping timeout: 276 seconds]
<skidd0>
my dept advisors want me to go to school
<skidd0>
because i pay them if i go to school
<White_Flame>
skidd0: if you want to get out of school, then push hard on actually getting industry contacts and job offers
<skidd0>
they are also the same idiots that fuck up my schedule every years
<dlowe>
no need to be cynical before checking it out
<skidd0>
i have two jobs
<dlowe>
also, you may be able to transfer to a course of study you like more
<skidd0>
one is doing IT Transition work for a company that wants to be sold
<White_Flame>
but when it comes to security, I think the uni papers are still a barrier to entry
<skidd0>
yeah...
<skidd0>
man fuck
<skidd0>
guess i gotta 'man up'
<warweasle>
skidd0: *Person* up. :P
<White_Flame>
automaton up
<dlowe>
embolden thyself
<skidd0>
i am
<skidd0>
that's why im here
<warweasle>
Embolden an italicize yourself!
<skidd0>
you know what they taught me in an OOP class?
<White_Flame>
static?
<skidd0>
that inheritance is a thing
<warweasle>
skidd0: Do I want to know?
<skidd0>
not why its a thing
<skidd0>
not why it's good or usefull
* jackdaniel
thinks this discussion steadily moves offtopic (that is in #lispcafe direction;)
<dlowe>
we're pretty far from talking about lisp now
<skidd0>
oh
<warweasle>
CLOS is good.
<skidd0>
fair enough
<dlowe>
but I like chatting about programming if you want to talk about oop in #lispcafe
<skidd0>
i would feel od going to another channel just to complain
<skidd0>
i'll stay on topic
surya has quit [Remote host closed the connection]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<skidd0>
oh hey anyone with experience using UIOP?
thodg has joined #lisp
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
Folkol has joined #lisp
<Xach>
phoe: no news
<Xach>
skidd0: yes
<phoe>
Xach: aw! do you need any help getting your hard drive?
<skidd0>
xach, on a high level, when might one use your buildapp vs uiop
<Xach>
skidd0: for building binaries? not sure. i don't know what uiop offers.
<Xach>
It is probably more ported so that would be useful on not-SBCL and not-Clozure CL
<White_Flame>
it's always best to just use the default facilities first and get a hang of what's going on and what needs to be done
<White_Flame>
then you can make better decisions on what features you need if you actually do need something more complex/bundled
<skidd0>
yeah i think i'm getting to far into the bushes
<Xach>
phoe: i have two hard drives and a fast computer running them but i have been away from home for a week so there has been no progress. i am optimistic i can build something soon. i really would like to get my old hard drive recovered though. that might involve shipping it somewhere.
<Xach>
I was once very disciplined about backups. I have been punished for backsliding into laxity.
thoth is now known as lugh
stacksmith has quit [Ping timeout: 256 seconds]
stacksmith has joined #lisp
rpg has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
kajo has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
fm4d_ has joined #lisp
<on_ion>
i sometimes wish that we had something like ChangeSets for lisp images, like squeak has for its smalltalk images
sauvin has quit [Remote host closed the connection]
defaultxr has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fikka has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
EvW has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
nika_ has quit [Quit: Leaving...]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rpg has joined #lisp
Kundry_Wag has joined #lisp
wigust- has joined #lisp
zachk has joined #lisp
zachk has quit [Changing host]
zachk has joined #lisp
wigust has quit [Ping timeout: 256 seconds]
MichaelRaskin has joined #lisp
FreeBirdLjj has joined #lisp
<phoe>
Xach: I see. Good luck with it!
nickenchuggets has joined #lisp
Pixel_Outlaw has joined #lisp
<pjb>
on_ion: don't dream, implement!
Quetzal2 has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
Kundry_W_ has joined #lisp
engblom has quit [Read error: Connection reset by peer]
engblom has joined #lisp
orivej has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
random-nick has joined #lisp
Pixel_Outlaw has quit [Ping timeout: 248 seconds]
vlatkoB has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
Kundry_Wag has joined #lisp
Kundry_W_ has quit [Ping timeout: 248 seconds]
FreeBirdLjj has quit [Ping timeout: 256 seconds]
<phoe>
on_ion: they already exist
<phoe>
they are called FASLs
<phoe>
(:
bugrum has quit [Remote host closed the connection]
Pixel_Outlaw has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
bugrum has joined #lisp
dented42 has joined #lisp
<on_ion>
phoe: er, already mentioned those earlier. intent of comparison to squeak smalltalk ChangeSets, those are portable across implementations and machines. they are essentially source code diffs.
fikka has joined #lisp
<phoe>
ooh. I see.
phenoble has joined #lisp
attila_lendvai has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 256 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
skidd0 has quit [Quit: WeeChat 2.1]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<pjb>
source code diffs are relatively portable…
<pjb>
Most often you cannot apply such patch, even on the same implementation and machine, when you try to apply them on a different version.
<pjb>
not without conflicts and a lot of rejected patches…
<Xach>
I remember I didn't want to try slime because i liked ILISP. But actually using it showed me how wrong I was. Even though at a high level they do the same things.
<Xach>
Sly is pretty nice and I wish I had more time to try it.
fikka has quit [Ping timeout: 276 seconds]
<Xach>
The slime video helped a ton in persuading me to try it. Reading static pages and screenshots, and using your imagination, is not always persuasive
DemolitionMan has joined #lisp
Kundry_Wag has joined #lisp
zotan has joined #lisp
epony has quit [Ping timeout: 256 seconds]
Kundry_W_ has quit [Ping timeout: 264 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
fikka has joined #lisp
<dim>
the cost of changing one's habit is very high, and slime is pretty good at what it does already
<Xach>
I really want stickers and multiple repls!!
<Xach>
The friction for me was down to keystrokes
<dim>
multiple repls? I think we have that already in slime, don't we?
<Bike>
it's a contrib
<Bike>
which might be broken
andrei-n has quit [Ping timeout: 248 seconds]
<Xach>
do we? ni
phenoble has quit [Quit: WeeChat 1.9.1]
<attila_lendvai>
slime has most of the cool stuff stuffed away in contribs, e.g. the fuzzy completion
fisxoj has joined #lisp
babathreesixty has quit [Quit: babathreesixty]
arubin has quit [Quit: Connection closed for inactivity]
babathreesixty has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
babathreesixty has quit [Client Quit]
babathreesixty has joined #lisp
jeosol has joined #lisp
LiamH has quit [Quit: Leaving.]
bugrum has quit [Remote host closed the connection]
papachan has quit [Quit: WeeChat 2.1]
kajo has joined #lisp
fraya has quit [Remote host closed the connection]
light2yellow has quit [Quit: light2yellow]
shifty has joined #lisp
doanyway has joined #lisp
EvW has quit [Remote host closed the connection]
EvW has joined #lisp
attila_lendvai has quit [Ping timeout: 276 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_W_ has joined #lisp
Quetzal2 has quit [Quit: ?? Bye!]
Kundry_Wag has quit [Ping timeout: 256 seconds]
jmercouris has quit [Remote host closed the connection]
stnutt has quit [Ping timeout: 276 seconds]
obicons has quit [Ping timeout: 256 seconds]
random-nick has quit [Read error: Connection reset by peer]
stnutt has joined #lisp
nirved has quit [Quit: Leaving]
nirved has joined #lisp
varjag has quit [Ping timeout: 255 seconds]
babathreesixty has quit [Quit: babathreesixty]
orivej has quit [Ping timeout: 245 seconds]
babathreesixty has joined #lisp
Bicyclidine is now known as Bike
Kundry_W_ has quit [Remote host closed the connection]
babathreesixty has quit [Client Quit]
Guest8344 has quit [Remote host closed the connection]
babathreesixty has joined #lisp
shangul has joined #lisp
wigust- has quit [Ping timeout: 264 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
RTZ0x859 has joined #lisp
robotoad has quit [Quit: robotoad]
Mutex7 has quit [Quit: Leaving]
lumm has quit [Ping timeout: 240 seconds]
element_ has joined #lisp
element_ has quit [Read error: Connection reset by peer]