<no-defun-allowed>
ETAOIN SHRDLU are the 12 most common letters in English, from most common to least
<no-defun-allowed>
iirc, the pdp10 had 36 bit words that could be split into 6 6 bit characters, so the grouping of 6 chars makes sense
robdog has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
you should memorise it if you play hangman a lot
notzmv has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<la_mettrie>
trying to figure out how to run these example codes on SLIME. i can select "run inferior lisp" for the window which has one of these codes pasted but it gives no output http://landoflisp.com/source.html
<stylewarning>
Does Allegro CL support arrays of (COMPLEX DOUBLE-FLOAT)? What is (upgraded-array-element-type '(complex double-float)) ?
nowhere_man has joined #lisp
techquila has joined #lisp
<pjb>
la_mettrie: you need to load those files, and the call the functions in them.
<la_mettrie>
i hope i have got it right that i do not need to compile them just for testing
<pjb>
la_mettrie: it's probably better to read the book at the same time, since some files contain redefinitions, so you would have to evaluate the definitions one by one, and try them out separately.
<pjb>
la_mettrie: yes, compilation is just an optimization.
robdog has joined #lisp
polezaivsani has quit [Ping timeout: 246 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
<Josh_2>
Can I check the value of an objects property in a method definition?
<Josh_2>
so that method is called when that property is a certain value?
bilb_ono has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
i don't think so
<Josh_2>
alrighty
robdog has joined #lisp
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
bilb_ono has quit [Quit: bilb_ono]
quazimodo has joined #lisp
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
dale has quit [Quit: dale]
Essadon has quit [Quit: Qutting]
dreamcompiler has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
blizzack has joined #lisp
robdog has joined #lisp
blizzack has left #lisp [#lisp]
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
bilb_ono has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
bilb_ono has quit [Client Quit]
robdog has joined #lisp
wanz has joined #lisp
bilb_ono has joined #lisp
bilb_ono has quit [Client Quit]
<Josh_2>
With a closs class can I list all the accessors?
robdog has quit [Ping timeout: 252 seconds]
bilb_ono has joined #lisp
robdog has joined #lisp
bilb_ono has quit [Client Quit]
<Bike>
i mean, you can do (if (slot-value ...) ...code... (call-next-method)) in the method body of course.
robdog has quit [Ping timeout: 252 seconds]
<Bike>
you can get all the slots of a class, but usually you should be specific enough to not need it
<Josh_2>
uhm well I need to create an instance of my class from an sql database
<Josh_2>
I suppose I can just write it manually
<Josh_2>
or just use funcall
<Bike>
oh, if you have a bunch of classes based on schema or whatever that might be a reasonable place to want that
<loke>
Josh_2: you can access all the slots using the MOP
<Josh_2>
oof
<loke>
Josh_2: I created a metaclass that automatically maps CLOS objects to CouchDB
<loke>
All you do is to set the metaclass to a specific name, and then everything else is automatic
<loke>
Josh_2: Then you should perhaps take it easy. :-)
<loke>
Josh_2: One thing you need to understand is that accessors are just normal functions that just happen to get or set values of slots. There is nothing magic about them, to attempting to list them makes no sense. If you programmatically want to access a slot based on its name, you use SLOT-VALUE.
robdog has joined #lisp
<Josh_2>
hmm
<Josh_2>
Oof that worked
<Josh_2>
I put the symbols for the accessors like 'username etc into a list, then used loop to iterate over them and set them so I can return the object
<loke>
Indeed
<Josh_2>
so I can create an object from a list
<loke>
And you can find all the slots for a given class using CLASS-SLOTS
<loke>
(load “closer-mop” and use (CLOSER-MOP:CLASS-SLOTS (FIND-CLASS 'name-of-class))
<Josh_2>
:O
<loke>
I just used the following to get the names of all the slots in the class CLIM-CLX:CLX-PORT:
<Josh_2>
however I gotta keep the accessors in a certain order, so probably best just leave it as a list for now
quazimodo has quit [Ping timeout: 246 seconds]
dddddd has quit [Remote host closed the connection]
robdog has joined #lisp
dale has joined #lisp
sjl has joined #lisp
ealfonso has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
ealfonso has joined #lisp
techquila has quit [Ping timeout: 252 seconds]
bilb_ono has joined #lisp
robdog has joined #lisp
<Josh_2>
I never actually solved the issue I had today, I just spent my time converting my code to clos xD
quazimodo has joined #lisp
xkapastel has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
<fiddlerwoaroof>
minion: memo for jmercouris: I've occasionally had build issues on lispworks with serapeum, but I
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
<pillton>
fiddlerwoaroof: Haha.
<fiddlerwoaroof>
minion: memo for jmercouris: never have noticed any real serious problems with it
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
charh has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
gravicappa has joined #lisp
<fiddlerwoaroof>
pillton: I hate it when I accidentally hit neter
<fiddlerwoaroof>
... or enter, for that matter
<pillton>
fiddlerwoaroof: I am of the view that you should never do the following:
domovod has quit [Quit: WeeChat 2.4]
space_otter has joined #lisp
aeth has quit [Ping timeout: 245 seconds]
Bike has quit [Quit: Lost terminal]
<fiddlerwoaroof>
pillton: interesting!
aeth has joined #lisp
jprajzne has quit [Ping timeout: 246 seconds]
<pillton>
I thought that is what you were doing to jmercouris.
<fiddlerwoaroof>
No, I hit enter before I had finished my memo :)
bilb_ono has quit [Quit: bilb_ono]
robdog has joined #lisp
bilb_ono has joined #lisp
impulse has joined #lisp
nanoz has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
bilb_ono has quit [Quit: bilb_ono]
impulse has quit [Quit: Lost terminal]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Oladon has joined #lisp
robdog has joined #lisp
Fare has quit [Ping timeout: 246 seconds]
elderK has joined #lisp
techquila has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
bilb_ono has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
<beach>
Good morning everyone!
<fiddlerwoaroof>
morning beach!
nanoz has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
paul0 has quit [Quit: Leaving]
nalkri has joined #lisp
ltriant has quit [Quit: leaving]
nowhere_man has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
dale has quit [Quit: dale]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Oladon has quit [Quit: Leaving.]
robdog has joined #lisp
space_otter has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
wanz has quit [Quit: wanz]
sauvin has joined #lisp
bilb_ono has quit [Quit: bilb_ono]
xkapastel has quit [Quit: Connection closed for inactivity]
Inline has quit [Quit: Leaving]
wanz has joined #lisp
robdog has joined #lisp
vlatkoB has joined #lisp
wigust- has joined #lisp
zooey has quit [Ping timeout: 256 seconds]
malm_ has joined #lisp
zcid- has joined #lisp
kushal has joined #lisp
wigust has quit [Ping timeout: 245 seconds]
jprajzne has joined #lisp
robdog_ has joined #lisp
zooey has joined #lisp
kdas_ has quit [Ping timeout: 256 seconds]
cantstanya has quit [Ping timeout: 256 seconds]
robdog has quit [Ping timeout: 252 seconds]
nefercheprure has joined #lisp
edgar-rft has quit [Read error: Connection reset by peer]
malm has quit [Quit: Bye bye]
zcid has quit [Quit: ZNC 1.7.0+deb0+trusty1 - https://znc.in]
AeroNotix has quit [Ping timeout: 246 seconds]
TMA has quit [Ping timeout: 246 seconds]
Mon_Ouie has quit [Ping timeout: 246 seconds]
surrounder has quit [Ping timeout: 246 seconds]
cantstanya has joined #lisp
zcid- is now known as zcid
robdog_ has quit [Ping timeout: 252 seconds]
themsay has quit [Ping timeout: 246 seconds]
dgi has quit [Ping timeout: 246 seconds]
AeroNotix has joined #lisp
Mon_Ouie has joined #lisp
edgar-rft has joined #lisp
robdog has joined #lisp
bilb_ono has joined #lisp
jprajzne has quit [Quit: jprajzne]
robdog has quit [Ping timeout: 252 seconds]
karlosz has joined #lisp
jprajzne has joined #lisp
p9fn has joined #lisp
milivoj has joined #lisp
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<Grue`>
is it possible to make postmodern execute a query but not wait until the result is returned?
robdog has joined #lisp
<flip214>
Grue`: using another thread?
<shka_>
Grue`: yeah, it is, read the manual
<Grue`>
flip214: using another thread is the last resort since it's for a webapp and I don't want to spawn more threads than needed
<Grue`>
I'm thinking lparallel thread pool or something
<shka_>
wow, or not
robdog has quit [Ping timeout: 252 seconds]
<Grue`>
but some async solution would be the best
<shka_>
Grue`: i thought that i remember using async interface in postmodern, but i can't find it in the manual
<Grue`>
basically i want to log stuff into database but not slow down requests by waiting for the write to complete
<shka_>
so maybe my memory is misleading me
<Grue`>
well obviously i'd read the manual first before asking here ;)
<shka_>
sorry :(
<flip214>
Grue`: how about having a single thread that waits for log data on a queue, and pushes that into the database?
<flip214>
that means only a single additional thread, and should be fast enough
nalkri has quit [Ping timeout: 252 seconds]
themsay has joined #lisp
<Grue`>
yeah, that's kind of what I'm leaning towards
<Grue`>
just need to make sure it doesn't eat all my cpu since I apparently only have 1 core on my server :)
nowhere_man has joined #lisp
robdog has joined #lisp
brocco has joined #lisp
aindilis has quit [Ping timeout: 250 seconds]
bilb_ono has quit [Quit: bilb_ono]
aindilis has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Ukari has quit [Remote host closed the connection]
Ukari has joined #lisp
robdog has joined #lisp
JohnMS_WORK has joined #lisp
varjag has joined #lisp
meepdeew has joined #lisp
<fiddlerwoaroof>
Most of the time spawning a thread for a query and forgetting about it wont cause any problems
<fiddlerwoaroof>
The query will execute and quit and the thread will go away: it's very similar to running a command at the shell, the OS can handle it
robdog has quit [Ping timeout: 252 seconds]
meepdeew has quit [Ping timeout: 245 seconds]
scymtym has quit [Ping timeout: 272 seconds]
Ricchi has quit [Quit: Leaving]
<flip214>
fiddlerwoaroof: the problem is that if you have 20 HTTP requests at once, each will start another thread, and each of the threads wants to make a database connection, etc.
<flip214>
one thread and a queue is much simpler, conceptually
nowhere_man has quit [Ping timeout: 252 seconds]
aindilis has quit [Ping timeout: 246 seconds]
<splittist>
Good morning
robdog has joined #lisp
<beach>
Hello splittist.
robdog has quit [Ping timeout: 252 seconds]
milivoj_ has joined #lisp
milivoj_ has quit [Remote host closed the connection]
gju has joined #lisp
milivoj_ has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
heisig has joined #lisp
milivoj has quit [Ping timeout: 246 seconds]
milivoj_ is now known as milivoj
aindilis has joined #lisp
edgar-rft has quit [Read error: Connection reset by peer]
wanz has quit [Quit: wanz]
robdog has joined #lisp
milivoj has quit [Quit: milivoj]
wanz has joined #lisp
lumm has joined #lisp
<Ukari>
how to optimize (length (list)) when (declaim (optimize (speed 3) (safety 0)))?
<beach>
Replace it with 0.
robdog has quit [Ping timeout: 252 seconds]
matijja has joined #lisp
<Ukari>
oh, i try list-length and it works
<beach>
What do you mean?
<no-defun-allowed>
Replace it with (sb-ext:quit "Segmentation fault")
robdog has joined #lisp
<beach>
Ukari: I understand you yourself want to optimize (length (list)). Then it doesn't matter what the optimize settings are.
rozenglass has quit [Ping timeout: 252 seconds]
schweers has joined #lisp
<beach>
Ukari: And (length (list)) is always 0, so you don't need to use list-length or anything else.
<flip214>
Ukari: you meant (LENGTH my-list-variable), right? (LENGTH (LIST)) is asking for the length of a newly created empty list.
<beach>
Ukari: So your question is not about optimizing it, but about how to avoid the note?
<beach>
Ukari: And you said (length (list)) but you meant something else.
<Ukari>
the note comes out when declaim optiomize
<beach>
Ukari: Kind of hard to help you in such situations.
<no-defun-allowed>
Well, that looks fine to me, unless you're sure that (ARIA.CONTROL.RX::INNERS ARIA.CONTROL.RX::SUBSCRIBER) is going to be a list.
surrounder has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<beach>
Ukari: Why are you using those optimize settings anyway?
<Ukari>
yes it is a list, but using function length for type list is not enough for (declaim (optimize)), insteadly using function list-length gives enough imformation for optimze i guess
<flip214>
Ukari: can you declare a return type for ARIA.CONTROL.RX::INNERS?
lumm has quit [Remote host closed the connection]
<no-defun-allowed>
Yeah, why do you need unsafe code?
<Ukari>
I thought it would be slow with out use (declaim (optimize))
<no-defun-allowed>
(safety 0) produces unsafe code with no type checks.
<beach>
Oh dear!
<no-defun-allowed>
(declaim (optimize (speed 3) (safety 1))) is the usual declamation.
<beach>
Ukari: Unless you know 1. that your code is unacceptably slow and 2. where in your code there is a problem, don't try that kind of optimization.
<beach>
Ukari: Especially not the SAFETY part.
<beach>
Ukari: Where did you get the idea that this is the thing to do?
<Ukari>
i get it, by the way, would it matter without type checks in runtime, if the code is written right?
<no-defun-allowed>
Yes, but if you (metaphorically) breathed on it too hard, it could quite easily crash.
<Ukari>
in stackoverflow
<no-defun-allowed>
Oh dear.
<no-defun-allowed>
There's probably a larger density of Lisp programmers on #lisp than on stackoverflow. C programmers and some other types are used to unsafe code.
scymtym has joined #lisp
<no-defun-allowed>
And of course, most of the language-caused security problems we see today (such as buffer overflows) occur in C programs. It looks fine, but you have to remember that every user of your program won't be as kind to it as you are.
<Ukari>
your are right, I need a safety code from prevent buffer overflows, i will use a safety 1
themsay has quit [Ping timeout: 246 seconds]
<beach>
Ukari: No, use safety 3.
<beach>
And use speed 0, debug 3, compilation-speed 0, until you know that you have a performance problem.
<no-defun-allowed>
Good point, full safety is usually better for debugging and testing.
<shka_>
just don't use safety 0
<shka_>
it is PITA to debug
<no-defun-allowed>
Absolutely. It's the easiest way to crash your Lisp image.
<shka_>
not sure about the easiest part
<shka_>
but it produces huge ammounts of hedache
<no-defun-allowed>
If you do, the LDB inspector will come your way, trying to figure out who killed an innocent Lisp system, and you'll be on a list for process mishandling.
<p_l>
shka_: with safety 0, I managed to overwrite the function from within
<shka_>
cute
<p_l>
through a stupid error on my part xD
<no-defun-allowed>
Well, (loop collect 'foo) is a good way to burn out your heap, but incorrect types passed to an unsafe function makes it a little more vivid.
<shka_>
anyway, safety 0 should be used only in extream examples and only for very short functions
<p_l>
no-defun-allowed: changing literals in safety 0 environment
<shka_>
and only for functions that are not supposed to be used by other programmers
<p_l>
suddenly you have functions that work only once
<no-defun-allowed>
You know, you get a garbage object, the printer is confused, you get some random data, then the GC comes around and bang! you're in LDB
<no-defun-allowed>
Oh, yes. That's a nasty one.
<p_l>
I didn't break GC information, so no LDB, but damn was it a long debug session...
edgar-rft has joined #lisp
<shka_>
p_l: that could be avoided by not using safety 0
<p_l>
shka_: it could be, yes
<p_l>
but it was a valuable learning experience :)
<shka_>
if one would want to torture himself...
dreamcompiler has quit [Quit: dreamcompiler]
<p_l>
this reminds me that I'll probably have a bunch of code with safety 0 speed 3 debug 3 soon :<
<no-defun-allowed>
why debug 3 then?
<p_l>
and dynamic extent if not non-consing
<p_l>
no-defun-allowed: debug info is sacred
<no-defun-allowed>
gotta debug all the errors signalled by your check-free code
<p_l>
no-defun-allowed: debug info also gives information about code locations
<no-defun-allowed>
aight
powerbit has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
Arcaelyx_ has quit [Ping timeout: 245 seconds]
terpri_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
terpri has quit [Ping timeout: 245 seconds]
karlosz has quit [Quit: karlosz]
angavrilov has joined #lisp
nirved has quit [Killed (niven.freenode.net (Nickname regained by services))]
nirved has joined #lisp
robdog has joined #lisp
Zaab1t has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Zaab1t has quit [Client Quit]
rozenglass has joined #lisp
robdog has joined #lisp
<p_l>
IIRC, with debug set to 0 you are not guaranteed that post-compilation debugger will know information about types of arguments etc.
themsay has joined #lisp
wanz has quit [Quit: wanz]
heisig has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 252 seconds]
q3d has joined #lisp
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
<shka_>
p_l: that is correct
wanz has joined #lisp
nefercheprure is now known as TMA
nowhere_man has joined #lisp
dddddd has joined #lisp
heisig has joined #lisp
nowhere_man has quit [Ping timeout: 246 seconds]
gravicappa has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
myrkraverk has quit [Ping timeout: 244 seconds]
gravicappa has joined #lisp
djh has left #lisp [#lisp]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
ggole has joined #lisp
wanz has quit [Quit: wanz]
spacedbat has joined #lisp
jello_pudding has joined #lisp
wanz has joined #lisp
m00natic has joined #lisp
themsay has quit [Ping timeout: 252 seconds]
themsay has joined #lisp
nalkri has joined #lisp
jello_pudding has quit [Quit: Leaving, Quit]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
techquila has quit [Ping timeout: 272 seconds]
_whitelogger has joined #lisp
vlatkoB has joined #lisp
robdog has joined #lisp
orivej has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
akater has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
makomo has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
polezaivsani has joined #lisp
wxie has joined #lisp
jello_pudding has joined #lisp
figurelisp has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
<flip214>
parenscript doesn't translate ASSERT yet; can I mark forms as not-to-be-translated to JS?
Lord_of_Life_ has joined #lisp
Fare has joined #lisp
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life_ is now known as Lord_of_Life
rozenglass has quit [Read error: Connection reset by peer]
robdog has joined #lisp
figurelisp has left #lisp [#lisp]
nowhere_man has joined #lisp
rozenglass has joined #lisp
rozenglass has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 240 seconds]
nowhere_man has quit [Ping timeout: 252 seconds]
rozenglass has joined #lisp
nowhere_man has joined #lisp
vaporatorius has joined #lisp
q3d has quit [Ping timeout: 256 seconds]
robdog has joined #lisp
<spacedbat>
flip214: if you want assert forms to translate to nothing in javascript, this ought to do it:
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
jprajzne has quit [Remote host closed the connection]
robdog has joined #lisp
LiamH has joined #lisp
q9929t has joined #lisp
q3d has quit [Ping timeout: 256 seconds]
robdog has quit [Ping timeout: 252 seconds]
q9929t has quit [Quit: q9929t]
robdog has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
edgar-rft has quit [Quit: Leaving]
FreeBirdLjj has quit [Ping timeout: 246 seconds]
Ukari has quit [Ping timeout: 272 seconds]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
SaganMan has joined #lisp
Ukari has joined #lisp
aeth has quit [Ping timeout: 252 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
aeth has joined #lisp
varjag has joined #lisp
Aruseus has joined #lisp
dyelar has quit [Quit: Leaving.]
chewbranca has joined #lisp
schweers has quit [Ping timeout: 240 seconds]
bilb_ono has joined #lisp
dyelar has joined #lisp
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
q3d has joined #lisp
dgi has joined #lisp
SaganMan has quit [Ping timeout: 252 seconds]
karlosz has joined #lisp
m00natic has quit [Remote host closed the connection]
igemnace has quit [Quit: WeeChat 2.4]
bilb_ono has quit [Quit: bilb_ono]
robdog has joined #lisp
rpg has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
lumm has joined #lisp
ggole has quit [Quit: Leaving]
edgar-rft has joined #lisp
karlosz has quit [Quit: karlosz]
robdog has joined #lisp
bilb_ono has joined #lisp
hiroaki has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<rpg>
Does anyone have a good suggestion for how to document a Lisp system? I am inclined to use SB-TEXINFO, because the way it makes a horde of individual include files lets me structure the doc as I would like. But... managing the nodes in Texinfo seems really burdensome. Any alternatives? I looked at some other libraries, but they all want to lay out the manual from docstrings only and don't easily accommodate manually written text.
<verisimilitude>
I document my libraries with simple justified text.
<rpg>
verisimilitude: This is a simply enormous system, with multiple sub-systems. There's a previous manual in (yuck) Word, but I would like to include material from docstrings, as well as the original (revised) text.
gareppa has joined #lisp
<rpg>
Somewhat surprisingly, there is no Latex style I could find, and the answers about "latex software manual" on stack exchange are all unsatisfactory.
aindilis has quit [Read error: Connection reset by peer]
* rpg
originally thought he could tweak sb-texinfo to emit Latex instead of texinfo
<pjb>
latex is a big dependency. I'd consider writing plain ascii files.
<pjb>
possibly, you could use org-mode and then you can export to html or latex/pdf.
aindilis has joined #lisp
<verisimilitude>
If it's an enormous system, my first advice would be to see if you could split it into several smaller systems, rpg.
kbtr has quit [Ping timeout: 245 seconds]
<rpg>
Texinfo has the advantage over org-mode, markdown, or even latex of supporting markup that makes semantically meaningful distinctions (e.g., between variables, functions, etc.), instead of just "text" and "code"
<rpg>
verisimilitude: There are indeed a half dozen smaller systems, with lower-level ones usable separately, but there is a pyramidal structure and I have only the energy for one manual!
gareppa has quit [Remote host closed the connection]
kbtr has joined #lisp
<beach>
rpg: Sadly, whenever documentation is discussed, the discussion is about markup syntax as opposed to the operations that can be used on the document. And since most markup systems define only input syntax and output formats, there is usually no other choice. To make things worse, there are so many markup languages available that, if you want to collaborate with other people, it is nearly impossible to get a majority to agree on one.
eschatologist_ is now known as eschatologist
<rpg>
beach: Agreed to all of these. Speaking of agreement, is there a place where the SBCL docstring style is described? I'm kind of guessing what will translate well into Texinfo and what won't...
rozenglass has quit [Ping timeout: 272 seconds]
<rpg>
beach: Markdown, org-mode, and restructured text all seem like instances of "worse is better". But that @Node BS in Texinfo is a huge disincentive to using it.
<pjb>
If tex was written in lisp and latex was sexpified, it would be perfectly acceptable.
<pjb>
At least, error message and logs would be readable…
sauvin has quit [Remote host closed the connection]
<verisimilitude>
If TeX were written in Lisp, it would cease to be TeX.
<beach>
rpg: I believe you. I have no experience with those.
<pjb>
rpg: If you want semantic markup, consider docbook.
<rpg>
verisimilitude: There *is* a tex in Lisp -- or at least in Racket. I won't be learning.
<verisimilitude>
Have you looked into pandoc, rpg; I haven't, but it's apparently good for this manner of thing, when it comes to conversion and whatnot; perhaps it can convert Word documents, even.
<pjb>
and indeed, pandoc is at the core of any document procesing system in this wild west world.
techquila has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
techquila has quit [Remote host closed the connection]
<rpg>
pandoc and docbook do seem appealing, but I 'm not able to learn YA markup language right now. I'll stick to Texinfo, for all it's warts. Thanks, everyone!
<jackdaniel>
funnily enough I'm working right now on "london - documentation tool" which is an examiner and writer for documentation (with planned protocols to call programmatically)
<jackdaniel>
(clim tool)
techquila has joined #lisp
<pjb>
rpg: you already know docbook: it's sgml, just like html.
<rpg>
jackdaniel: Features I would like to see -- don't just extract the docstrings. A manual needs expository text, and its author should have the freedom to arrange the auto-generated or -harvested text as they like.
<verisimilitude>
From earlier, would you also classify what's commonly referred to as ``plain text'' in that ``worse is better'' category, rpg?
<jackdaniel>
rpg: docstrings are going to be treated only as an additional material
<rpg>
verisimilitude: Yes. Plain text (unlike Texinfo), for example will not generate an index of functions, an index of types, an index of variables, and an index of concepts, as Texinfo will.
<verisimilitude>
My documentation strings are rather separate from the outside documentation; they serve two very different purposes and the latter is able to be justifiably larger than the former.
<verisimilitude>
That's interesting, then, rpg; I'd be inclined to disagree there; it's not advanced and it's not better than other formats, but it serves a purpose well; I'd think it's very distinct from the worse is better attitude.
<rpg>
I think the SBCL manual actually does a pretty good job of getting this right: it has an overall structure that is organized by topic, and built by humans, but can harvest whatever is useful in the docstrings.
<rpg>
verisimilitude: What I mean by worse is better is that these simpler approaches are good at the compromise between legibility and format-ability, but they do a poor job of capturing semantics. On the other hand XML does a great job of capturing semantics but is otherwise a nightmare from hell.
<verisimilitude>
My main issue with plain text would be the ASCII encoding, but it does have the advantage of being a lowest common denominator that extends to the near beginning of automatic computing. It has issues, but it's distinct from worse is better, which tends to neither be simple nor useful nor truly common enough to be useful for such.
verisimilitude has quit [Remote host closed the connection]
verisimilitude has joined #lisp
verisimilitude has quit [Remote host closed the connection]
verisimilitude has joined #lisp
verisimilitude has quit [Remote host closed the connection]
<rpg>
versimilitude: I suppose you could use some more expressive form of unicode. I've been using that in my emails these days -- in the old days I would use Latex source when I needed to explain something mathematical.
verisimilitude has joined #lisp
robdog has joined #lisp
<verisimilitude>
I agree with you that it lacks semantic structure, sure.
Necktwi has quit [Quit: leaving]
robdog has quit [Read error: Connection reset by peer]
xkapastel has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
robdog has quit [Ping timeout: 252 seconds]
vlatkoB has quit [Remote host closed the connection]
vms14 has joined #lisp
<vms14>
guys I want to make a web project about lisp which will serve as a portfolio for when my teacher talks with the enterprises in order to get me a job
<vms14>
we could choose, so I've chosen talk about lisp
<vms14>
the problem is since I'm just a noob and I have almost 0 knowledge of lisp, idk what I could say or learn/explain to create a bit interest to lisp from thereaders
<vms14>
what I should show in order to make the reader be interested in lisp, or consider at least it is a good language and has unique features?
<jackdaniel>
vms14: you may discuss a condition system and compare it to exceptions in java, c++ and error handling in other languages
<vms14>
jackdaniel, thanks, it seems a good point
<jackdaniel>
also provide some insight how it may be used for things truly unrelated to error handling, i.e aspect programming, interactive recovery and such
<vms14>
I've just looked for 5 min at lisp error handling and it seems a nice system, better than what we usually see in most languages
<jackdaniel>
it is truly magnificient
<vms14>
thanks for the hint
<jackdaniel>
sure
<vms14>
I have no idea, so I need to learn and I have not much time, but I'll try to give a bit decent explaination
<vms14>
it should be simple for the reader, but also show the power it has
<vms14>
so I'll list condition system
<jackdaniel>
I think that if you do not feel sure on this ground maybe a better choice would be to discuss something else? in worst case scenario you may do more harm than good (language popularity wise)
<vms14>
jackdaniel, yeah, too late for that anyway
<vms14>
we cannot change it yet
<vms14>
also I'd like to use it as excuse to learn lisp
<vms14>
because I try to focus on webdev with that course, and I did nothing with lisp
<vms14>
Also I want to make some sort of interactive tutorial using the cgi from heliohost
<verisimilitude>
Well, homoiconicity is one of Lisp's nicer qualities, to me.
<verisimilitude>
I doubt your peers are at all familiar with that.
<vms14>
yeah, ofc I should talk about macros and `data,code stuff
<rpg>
vms14: CLOS is a pretty amazing object system.
<vms14>
but the problem is I like lisp because there is something inside me telling that this language is really powerful
<vms14>
but I cannot see that power yet, since I've learned nothing xD
<jackdaniel>
minion: tell vms14 about paip
<minion>
vms14: paip: Paradigms of Artificial Intelligence Programming. More about Common Lisp than Artificial Intelligence. Now freely available at https://github.com/norvig/paip-lisp
<vms14>
I'd like to show at least some interesting stuff from lisp and try to achieve the reader at least consider lisp as a language
<rpg>
Also there's Peter Seibel's Practical Common Lisp. Also available on line.
<vms14>
or make grow a bit of interest
<rpg>
Actually, I bet looking at PCL's introduction would be helpful -- he must have something in there that tries to coax you to learn the language.
<vms14>
thanks for the hints, if you guess I should name something more, just tell me
hiroaki has quit [Ping timeout: 246 seconds]
<vms14>
I want to show the power of lisp, even if I don't understand its power yet
<vms14>
I just have something in my mind saying "This language is a special tool"
<vms14>
but nothing to prove that
<jackdaniel>
tool like any other, good for some, bad for other uses
<vms14>
the thing it interests me about lisp is metaprogramming and reflexiveness
<vms14>
and that it seems to be the best language for prototyping
<vms14>
C programmers recommend to have a scripting language in hand. You use the scripting language to make prototypes and when you have the idea and the algorithm, you go for C
<pjb>
Instead, CL programmer use CL to make prototypes, and when we're have the idea and the algorithms, we call compile-file.
<vms14>
So knowing lisp is good for prototypes, and then good for programmers
<pjb>
Yes.
<vms14>
pjb, XD
<vms14>
also I'd like to explain why people say lisp changes your mind
<vms14>
a lot of programmers learn to program in some language, and they become experts. They know a lot of languages, but most of them does not know lisp even exists
<vms14>
We have not much time to do that project, so I cannot make an exaustive research. But I'll try to do something and look for useful info or something that could make the reader be interested in
<pjb>
vms14: also, for CL specifically, check PAIP Common Lisp Programming for Artificial Intelligence Tony Hasemer & John Domingue - 1989 International Computer Science Series Addison & Wesley ISBN 0-201-17579-7
<pjb>
Oops, not that reference.
<vms14>
yeah I have PAIP on my to-read list
<pjb>
ok.
<vms14>
but first I have the land or pcl, and then the onlisp book
<vms14>
and I'd like to read let over lambda too
<vms14>
I need to learn web development too, front and back
<vms14>
I'd like to start doing stuff with hunchentoot, but not now
<vms14>
I would like the days were longer xD
ravenousmoose has joined #lisp
<vms14>
btw, thanks again for the hints
<vms14>
I'll note them
<pjb>
The only practical solution accessible right now, is to marry a girl, make babies, and in 10-15 years, you can have a little team of mini-you to help you.
<pjb>
And if you educate them to do the same, in 35 years, you can exponentially grow this team!
<vms14>
verisimilitude, I want to explain that homoiconity is a nice feature to have, but idk what I could do about it
dddddd has quit [Ping timeout: 246 seconds]
<pjb>
You can write programs to generate programs.
<vms14>
have code data as same stuff it's what makes macros so powerful
<pjb>
Take most of the OO design patterns.
<pjb>
even without macros. Just having program reading programs, processing them and writing updated versions of them.
<vms14>
but will be hard to make one interesting macro example without understanding well the macros power
<vms14>
I could make a simple macro and use `code ,data to show it
hiroaki has joined #lisp
<vms14>
but surely the reader will think "ok, so what?"
<vms14>
because will be a shit example and not interesting enough
<pjb>
A first simple example, is to take a declaration-like expression, and to generate code from it. Notably, in the case of client/server protocols where the same specification must lead to two programs that must communicate using this protocol.
bilb_ono has quit [Quit: bilb_ono]
<pjb>
Being able to generate those programs from the same declarations ensure that the process is error-free, therefore smooth and quick.
<vms14>
also I cannot put a complicated macro ,first because I don't know and second because the reader won't get it
<jackdaniel>
don't jump at too many topics
<jackdaniel>
take one, study it and do your best with explanation
<jackdaniel>
otherwise without deeper understanding your presentation will end up being chaotic
<pjb>
vms14: I saying (loop (PRINT (process (READ))))
<vms14>
what means process?
gravicappa has quit [Ping timeout: 246 seconds]
<vms14>
you are not meaning the repl, so idk what you try to mean
<pjb>
(defun process (form) … )
<vms14>
what does change your mind when you learn lisp?
<vms14>
what you start to see different?
<vms14>
it's because the functional style?
<vms14>
metaprogramming?
<vms14>
the parens? xD
<pjb>
forgetting about malloc/free.
<vms14>
but most "modern" languages let you forget that
<pjb>
read above.
<vms14>
also I want to mention that modern languages are modern just because their "innovative" features are concepts stolen from lisp
<vms14>
I'll start by reading some "why lisp" posts
<vms14>
because one of the articles will be named why lisp
<jackdaniel>
don't use such negative wording in presentation (like "stealing ideas"), it will make you look smug and won't win you anything
<vms14>
jackdaniel, thanks for the recommendation, because it would be possible that I'd do it
<jackdaniel>
ideas influence each other and that leads do programming languages evolution
<jackdaniel>
for instance lisp's clos is influenced by smalltalk
<vms14>
I need to watch the way I say stuff
<jackdaniel>
(to clarify, I *think* someone told me that clos is influenced by smalltalk, I don't know the latter)
rozenglass has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<vms14>
also it is true that lisp invented the if statements?
<jackdaniel>
do you mean Samuel Edward Lisp, famous statement inventor?
<Bike>
no. i think you mean cond.
<vms14>
one thing I feel a bit strange is to see that lisp is one of the oldest languages of the world, but also one of the more "advanced"?
<vms14>
yeah it was cond, not if
<Bike>
i don't think history is the way to go if you want people to actually use it, really
<vms14>
but, there was no if or cond statement before lisp?
<Bike>
again, "if" already existed. and "cond" resembles piecewise function definitions, it's not that exciting
<vms14>
Bike, right, but I'll talk a bit of the history of lisp, and I'd like to remark that lisp is an old language, but the modern languages are modern just for having features lisp had all the time
<vms14>
Bike, then I've read wrong
<jackdaniel>
vms14: I don't think LISP 1.5 had all these exciting features people brag about when they talk about Common Lisp
<vms14>
thanks for the clarification, because I wanted to say that lisp invented the if xD
<vms14>
had closures and lambda?
<vms14>
had mapcar?
<jackdaniel>
also for all practical purposes Common Lisp is not LISP (however I think you could run some LISP 1.5 program with minimal curation)
<vms14>
and macros
<vms14>
wasn't common lisp considered as a lisp 2 and scheme as a lisp 1?
<vms14>
why scheme is considered a lisp 1?
<jackdaniel>
this distinction is about a separate namespace for functions and variables
<Bike>
it's different from the version number.
<jackdaniel>
scheme has one one namespace for functions and variables
bilb_ono has joined #lisp
<vms14>
yeah, it was in that context when I've read about that
<vms14>
I guess in the first pages of the sicpp
<vms14>
sicp*
<vms14>
but didn't know why lisp 1 and 2
nanoz has quit [Ping timeout: 250 seconds]
<verisimilitude>
Modern Lisps went in a direction of getting most of the abstraction, but with concessions for efficiency.
<verisimilitude>
Instead of functions being lists, they're opaque objects in Common Lisp, as an example.
<vms14>
would be a good choice to use a C program example to create a list with struct and pointers and show the lisp program with just two parens?
<vms14>
I need to talk about the abstractions lisp provides over other programming languages
<verisimilitude>
You may impress your peers more with Paul Graham's example of a function that produces other functions that increment their argument.
<vms14>
but I have no idea about those abstractions
Josh_2 has quit [Ping timeout: 246 seconds]
Josh_2 has joined #lisp
<verisimilitude>
If it helps, I feel one of Lisp's most important qualities is letting someone program without quite knowing what they're doing, vms14.
<verisimilitude>
That is, Lisp makes it simple to start off with lists instead of concrete objects, garbage collection since you don't know the memory behavior of the program, etc.
<vms14>
Paul Graham’s Hackers & Painters what shows of lisp that book?
<vms14>
I should also talk about lisp capabilities
<vms14>
and things like parenscript
<vms14>
or whatever could call the attention of a developer
rpg has joined #lisp
<vms14>
thanks for all, I'll do some research
<vms14>
ty for the links too
<edgar-rft>
have fun :-)
vms14 has quit [Quit: Doing something with my shit life :D]
robdog has joined #lisp
verisimilitude has quit [Remote host closed the connection]
meepdeew has joined #lisp
bars0 has joined #lisp
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
birkoff has joined #lisp
bilb_ono has quit [Quit: bilb_ono]
<birkoff>
how is LISP "powerful" compared to other languages ? as is often said ?
ravenousmoose has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
macros are pretty powerful, given they can do abbreviations, or compile a made-up language you'd prefer to tackle a problem into CL
verisimilitude has joined #lisp
Ricchi has joined #lisp
bilb_ono has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
robdog has joined #lisp
nalkri has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
bilb_ono has quit [Quit: bilb_ono]
meepdeew has quit [Remote host closed the connection]
bilb_ono has joined #lisp
bilb_ono has quit [Client Quit]
<pjb>
birkoff: lisp is powerful because it let you create abstractions easily (some other languages also allow abtraction creations), and to bind the to the syntax of the language easily and smoothly. (no other language let you do that easily if at all).
jack_rabbit has quit [Ping timeout: 252 seconds]
<birkoff>
bind what to the syntax
<birkoff>
?
<akater>
birkoff: `them', I guess
<pjb>
birkoff: we can create data abstractions (types, data structures, objects), functional abstractions (functions, anonymous functions), syntactic abstractions (reader macros, macros), and meta-linguistic abstractions (macros).
<birkoff>
how it differs from other langs ?
<pjb>
for example, if you can invent in lisp a new control structure, such as parallel execution. (in-parallel (f1) (f2) … (fn)) that will fun each subexpression in a different thread.
<pjb>
You cannot do that in C.
<birkoff>
how does lisp compare to more modern languages in that regard, like C# or Python ?
<pjb>
In C, you could only combine data abstractions and functionnal abstractions, but you couldn't write in_parallel{ f1(); f2(); … fn(); }
lumm has quit [Quit: lumm]
<pjb>
birkoff: Neither C# or Python have homoiconicity that let you use syntactic abstraction, or meta-linguistic abstraction easily.
<pjb>
For example, ruby has symbols, and you can write "sexps", but since the syntax is not homoiconic, it is difficult to use, and it cannot be integrated in the language.
<pjb>
It's still a powerful too, so it can be used, but most ruby programmers don't understand it.
<pjb>
Python is even worse, since it distinguishes statements from expressions like C.
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
<akater>
AFAIK, Python isn't even compiled (compiles to bytecode), thus is not even in the same league.
<pjb>
There are implementations that compile to native code. It's not a language question.
<Xach>
birkoff: there are many differences and it is a matter of priorities whether you consider those differences more powerful or not
robdog has joined #lisp
bilb_ono has joined #lisp
q3d has quit [Ping timeout: 256 seconds]
ealfonso has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 246 seconds]
ealfonso has joined #lisp
bars0 has quit [Ping timeout: 245 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
<akater>
I wasn't aware of Python implementations that compile to native code (still am not). Until they get mature, it's a valid comparison, I believe. Common Lisp features are slowly being adopted by other languages but the whole package is still only available here. “Highly dynamic yet compiled and efficient” is one of the features.
meepdeew has joined #lisp
<Xach>
syntactic abstraction is nice. multiple implementations of an independent standard are nice.
meepdeew has quit [Remote host closed the connection]
nowhere_man has joined #lisp
angavrilov has quit [Remote host closed the connection]
robdog has joined #lisp
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
orivej has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<aeth>
I'm writing a lot of C. So much repetitiveness that would hard to abstract in a reasonable way given the tools C has available. (Of course, a lot of people like how explicit C is.)
<pjb>
There's always the interpreter design pattern. #include <ecl/ecl.h> ;-)
<aeth>
Some of C boilerplate is language features e.g. (when foo (error ...)) is possible in CL, which is probably 95% of early returns in C and probably why there isn't a convenient (return) in defuns in CL.
<aeth>
But a lot of it is that you have a pattern but you'd have to be mad or skilled to want to use C macros to abstract it.
<aeth>
In CL, you build the language to fit your pattern.
<aeth>
C macros are like doing arithmetic by hand on paper. You probably won't do that for 1467378494*373783 and even if you do you'll probably make mistakes.
<aeth>
Now, C is admittedly an extreme opposite of CL here. But other languages overcome limitations by including a lot of batteries, like C++ or Python or Java. CL is a make your own battery kit.
makomo has joined #lisp
birkoff has quit [Read error: Connection reset by peer]
<verisimilitude>
Forth is also better at this than C.
vIkSiT has joined #lisp
vIkSiT has quit [Quit: Leaving]
Fare has joined #lisp
karlosz has joined #lisp
robdog has joined #lisp
moei has joined #lisp
Bike_ has joined #lisp
Bike has quit [Disconnected by services]
Bike_ is now known as Bike
fortitude has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<akater>
pjb: OK, I'm not aware how Cython fares compared to Lisp compilers but anyway, Cython compiles to C, and I thought people usually distinct between this and “compiles to native code”, that's all.
lumm has joined #lisp
<jackdaniel>
if something compiles to C and then gcc is invoked than native code is what's being executed
<jackdaniel>
in contrary to more or less sophisticated virtual machines
<jackdaniel>
(for instance JVM is a very sophisticated virtual machine which may outperform something making hops through compiling to C
<jackdaniel>
)
spoeplau has joined #lisp
eddof13 has joined #lisp
wxie has joined #lisp
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
Fare has quit [Ping timeout: 246 seconds]
karlosz has quit [Quit: karlosz]
Fare has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
wxie has quit [Ping timeout: 252 seconds]
DGASAU has joined #lisp
<TMA>
aeth: DEFUN name wraps the body in (BLOCK name ...) and you can RETURN-FROM that block -- that arguably is convenient enough, given that it does not interfere with loops flet/labels and such
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
orivej has quit [Ping timeout: 246 seconds]
q3d has joined #lisp
spoeplau has quit [Quit: rcirc on GNU Emacs 26.1]
hiroaki has quit [Ping timeout: 272 seconds]
LiamH has left #lisp [#lisp]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<akater>
jackdaniel: Yes but IMO it still makes a difference whether “native code compiler” relies on external compilers (or even, on assumptions about external architecture). Lisp community had always had such tools at hand's reach, and keeps improving them.
<akater>
LISP (the original one) emerged from conflux of a very abstract idea and a very low-level implementation. I find this deeply satisfying.
robdog has joined #lisp
<aeth>
TMA: Interesting. I've never seen this, but it works. (defun foo () (print "Hello") (return-from foo) (print "World") nil)
<aeth>
(also e.g. (return-from foo -42))
<aeth>
I think normally when people do this they make a BLOCK even when just using the function name would work.
robdog has quit [Ping timeout: 252 seconds]
<akater>
aeth: clhs explicitly says that defun implicitly puts a block named block-name around the body forms.
robdog has joined #lisp
ealfonso has quit [Ping timeout: 252 seconds]
nowhere_man has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
<aeth>
Don't actually do this but... hide the defun+macrolet pattern with a macro and you can pretend that your CL a "normal" language: (defun foo () (macrolet ((return* (&optional value) `(return-from foo ,value))) (return* 42)))
DGASAU has quit [Read error: Connection reset by peer]
<aeth>
s/CL a/CL is a/
<aeth>
It's probably best used in combination with infix reader macros.