<aeth>
If you declare then you have a function with e.g. the input (integer list vector). If you check-type then it has the input (T T T) since anything can technically be used as input.
makomo has quit [Ping timeout: 255 seconds]
<aeth>
This means that e.g. DECLAREd functions can have some static checking, but ones using CHECK-TYPE instead cannot, and it's all done at runtime. If you have both, it will delete the CHECK-TYPE as unreachable code.
dyens has quit [Quit: WeeChat 1.9.1]
robdog has joined #lisp
Jesin has quit [Quit: Leaving]
<aeth>
At (safety 0) it throws everything away, including compile time checks. Never (safety 0) except in niche cases, inside a LOCALLY.
<aeth>
(Or in benchmarks... really, it's just a benchmark cheating mode that's too unsafe for production.)
<aeth>
I think in every other implementation DECLARE is either roughly equivalent to CHECK-TYPE or is ignored.
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
<Ukari>
I thought it is possible for asdf to distinguish between a file and a directory which shares a same name
makomo has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
Achylles has quit [Ping timeout: 252 seconds]
notzmv has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
Would :depends-on ("foo") depend on the file foo or the directory foo?
<Bike>
i wouldn't do that just because it's confusing
<no-defun-allowed>
indeed, it's also very confusing if it does work
robdog has joined #lisp
<Ukari>
in (:file "foo" :depends-on ("this must be directory foo")), in (:module "foo" :depends-on ("this must be file foo"))
<Ukari>
foo/bar is the package :foo.bar
<Ukari>
and foo.lisp is the package :foo
<Ukari>
one file one package
<fouric>
pjb: ok, you're right, it doesn't refuse to compile it - i was misremembering some macroexpansion stuff
<Ukari>
and the directory couldn't be a package
<fouric>
aeth: so basically you get a choice between the ability to replace a value of the wrong type at runtime and better typechecking?
robdog has quit [Ping timeout: 252 seconds]
<fouric>
...and thanks for warning me not to (safety 0)
<fouric>
i had copied-and-pasted a DECLAIM form in a bunch of places that had (debug 3) so i had maximum debug info, but i also did (safety 0) which doesn't make any sense
<fouric>
any rules-of-thumb for that safety value? just turn it all the way up in development code?
<aeth>
Personally, I just keep things at default with the exception of (speed 3) in certain functions (i.e. in a top-level-to-the-function declare) where that enables smarter optimizations, like (potentailly, obviously implementation-specific) arithmetic-heavy code. I turn on (debug 3) or (debug 3) (safety 3) locally to a function and recompile if I need the value of a lexical variable.
robdog has joined #lisp
<aeth>
Some people develop with (debug 3) on globally, but I haven't yet had issues with enabling it just when I need to inspect the lexicals (lexical variables aren't guaranteed to exist at run time, but with (debug 3) they probably exist)
<verisimilitude>
My advice is to make no such declarations in code intended to be used by others, fouric.
aindilis has quit [Read error: Connection reset by peer]
<verisimilitude>
Ideally, the user would decide, and it's not as if an implementation is required to obey the majority of such declarations in any way.
<aeth>
e.g. (defun foo () (let ((x 42)) x)) probably removes x but (defun foo () (declare (optimize (debug 3))) (let ((x 42)) x)) probably doesn't remove x
aindilis has joined #lisp
<aeth>
verisimilitude: I think that's fair unless you're doing arithmetic-heavy functions, where it shouldn't be the burden of the user to figure out when (speed 3) is actually necessary (at least in common implementations).
<verisimilitude>
If it's slow, they could simply use a DECLAIM that affects everything.
robdog has quit [Ping timeout: 252 seconds]
<aeth>
I think it depends on what you're writing.
<aeth>
If I'm writing a framework, I'm absolutely going to expect to be doing a lot of the work, and making a lot of the decisions like declaring certain optimizations in certain places.
akater has quit [Remote host closed the connection]
CuriousCain has quit [Ping timeout: 246 seconds]
Khisanth has quit [Ping timeout: 245 seconds]
CuriousCain has joined #lisp
akater has joined #lisp
esrse has joined #lisp
jack_rabbit has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
CuriousCain has quit [Quit: WeeChat 2.2]
robdog_ has quit [Ping timeout: 240 seconds]
Khisanth has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
pillton has quit [Ping timeout: 264 seconds]
<verisimilitude>
That's fair enough, I suppose, but if you're like me and prefer to optimize for debugging, you'd interfere with someone who wanted to optimize differently.
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<fouric>
verisimilitude: hmm, alright
<fouric>
how should i configure my development environment such that when i work on my own code, it's all compiled with a certain set of optimization settings?
<fouric>
i think that declaim is compilation-unit-local so putting it in e.g. .sbclrc wouldn't work
<fouric>
or would it?
orivej has quit [Ping timeout: 245 seconds]
<verisimilitude>
I'll check for you.
<verisimilitude>
>If a use of this macro appears as a top level form in a file being processed by the file compiler, the proclamations are also made at compile-time.
<fouric>
"As with other defining macros, it is unspecified whether or not the compile-time side-effects of a declaim persist after the file has been compiled. "
<verisimilitude>
So, that if makes it clear to me that it doesn't behave in that way if it's not in a file being processed in that way.
wanz has joined #lisp
<fouric>
alright, so i can't use that...
<verisimilitude>
Oh, you should use PROCLAIM, really.
<verisimilitude>
>Establishes the declaration specified by declaration-specifier in the global environment.
<verisimilitude>
As you can guess, I never really have a need to use these, so I'm rusty on the details.
robdog has joined #lisp
<fouric>
hmmm, proclaim in my .sbclrc is having no effect for me at all
<fouric>
neither is sb-ext:restrict-compiler-policy
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
<fouric>
aha, there it goes
add^_ has quit [Ping timeout: 240 seconds]
wanz has quit [Quit: wanz]
wanz has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
cmack has joined #lisp
<fouric>
no, just kidding, it's actually not. well, i don't suppose anyone would be able to share with me how they configure optimization settings for their own environments?
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
dale has quit [Quit: dale]
wanz has quit [Quit: wanz]
wanz has joined #lisp
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
Volt_ has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
iovec has joined #lisp
Bike has quit [Quit: Lost terminal]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
marusich has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
wanz has quit [Quit: wanz]
Aruseus has quit [Remote host closed the connection]
holycow has joined #lisp
robdog has joined #lisp
slyrus_ has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
marusich has quit [Remote host closed the connection]
slyrus__ has quit [Ping timeout: 240 seconds]
marusich has joined #lisp
robdog has joined #lisp
dale has joined #lisp
dddddd has quit [Remote host closed the connection]
<beach>
Good morning everyone!
<Josh_2>
Mornin'
eschatologist has quit [Ping timeout: 264 seconds]
eschatologist has joined #lisp
<beach>
fouric: I use PROCLAIM in my .sbclrc and I set them to speed 0 compilation-speed 0 safety 3 debug 3
<Josh_2>
I have the same
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
pillton has joined #lisp
nanoz has joined #lisp
wanz has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
pierpal has quit [Quit: Poof]
akoana has joined #lisp
pierpal has joined #lisp
marusich has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog_ has joined #lisp
marusich has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<buhman>
a few months ago I tried implementing a compact prefix tree. I had a working "lookup" function that worked well for finding terminal nodes (or nothing), but once I started trying to implement insertion, I found I needed to write a similar but completely different lookup function, and I never managed to model the result in a way that made sense for transforming the tree appropriately.
<buhman>
all of the compact prefix tree implementations I've found also seem convoluted or poorly implemented. Does anyone know of better reference material or guidance on the better approaches for implementing these?
wanz has quit [Remote host closed the connection]
robdog has joined #lisp
wanz has joined #lisp
<beach>
buhman: Let me take a minute to refresh my knowledge about prefix trees.
robdog_ has quit [Ping timeout: 252 seconds]
Volt_ has quit [Ping timeout: 246 seconds]
<beach>
buhman: That does look intrinsically messy for insertion.
<buhman>
yeah, that's where I started reading from
<beach>
So you are basically looking to factor the search needed for insertion and the search needed for lookup?
<buhman>
I think it would be convenient if they were the same implementation
<beach>
Sounds right.
<buhman>
(the wikipedia article vaguely suggests they aren't)
<beach>
I see that, yes.
<beach>
Interesting problem. I have no quick solution for you, unfortunately.
<beach>
I mean, I would have to code it up to see for myself.
<beach>
But I won't take that on right now.
<buhman>
of course. i've been simultaneously wanting to retry this and procrastinating on actually doing so for some time now myself :)
robdog has joined #lisp
<beach>
I can offer to review your code if you decide to act upon it.
<buhman>
thanks!
<beach>
To factor the search, you would probably have to stop "when no further progress can be made" and then act differently according to whether you have insertion or lookup.
<beach>
Perhaps you need a search subroutine that searches the suffix of a string from a particular node.
<beach>
As in (defun search (string start from-node) ...)
robdog_ has joined #lisp
<beach>
That returns a node and suffix.
<beach>
If you do a lookup and this function returns an empty suffix and a node that matches, you have a match.
robdog has quit [Ping timeout: 252 seconds]
<beach>
I guess "a node that matches" means a leaf in the compact case.
torbo has quit [Remote host closed the connection]
robdog has joined #lisp
Volt_ has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<fouric>
beach: aha! i'll try that, thank you very much!
robdog has joined #lisp
<fouric>
it...doesn't appear to work, at least when i quickload a system. is there some caching going on?
Oladon has quit [Quit: Leaving.]
robdog_ has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
<beach>
fouric: It should have global effect whenever you start your new image.
<beach>
What makes you think it is not working?
<beach>
Individual systems can override it, of course.
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
polezaivsani has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
nalkri has quit [Ping timeout: 272 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
quazimodo has quit [Ping timeout: 272 seconds]
<makomo>
morning
robdog has quit [Ping timeout: 252 seconds]
nalkri has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
bgardner has quit [Ping timeout: 255 seconds]
vlatkoB has joined #lisp
robdog has joined #lisp
drdo has quit [Ping timeout: 250 seconds]
drdo has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
JohnMS_WORK has joined #lisp
igemnace has quit [Quit: WeeChat 2.4]
wigust- has joined #lisp
robdog has quit [Read error: Connection reset by peer]
wigust has quit [Ping timeout: 245 seconds]
Ukari has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
Ukari has joined #lisp
robdog_ has joined #lisp
angavrilov has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
karlosz has quit [Quit: karlosz]
schweers has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
Fare has quit [Ping timeout: 252 seconds]
nanozz has quit [Ping timeout: 272 seconds]
robdog has joined #lisp
Fare has joined #lisp
robdog_ has joined #lisp
techquila has quit [Ping timeout: 246 seconds]
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
techquila has joined #lisp
Fare has quit [Ping timeout: 245 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
varjag has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
rozenglass has quit [Ping timeout: 240 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
FreeBirdLjj has joined #lisp
robdog_ has joined #lisp
<splittist>
morning makomo
akoana has left #lisp [#lisp]
robdog has quit [Ping timeout: 252 seconds]
marusich has quit [Ping timeout: 252 seconds]
robdog_ has quit [Read error: Connection reset by peer]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
Arcaelyx has quit [Ping timeout: 245 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
igemnace has joined #lisp
robdog has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
edgar-rft has quit [Quit: Leaving]
hhdave has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
keep_learning_M has quit [Quit: This computer has gone to sleep]
marcoecc has joined #lisp
robdog_ has quit [Read error: Connection reset by peer]
robdog has joined #lisp
nanozz has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
pankajgodbole has joined #lisp
robdog_ has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<pankajgodbole>
Hi
keep_learning_M has joined #lisp
robdog has joined #lisp
<beach>
Hello pankajgodbole.
<beach>
pankajgodbole: Are you new here? I don't recognize your nick.
keep_learning_M has quit [Client Quit]
<pankajgodbole>
Yes, new to Lisp
<beach>
I see.
<pankajgodbole>
I have a noob question:
<pankajgodbole>
why does (list 'quote 'foo) evaluate to 'foo
<shka__>
after you call eval on it?
<beach>
pankajgodbole: That's just the way the Common Lisp print function shows (quote foo).
robdog_ has joined #lisp
techquila has quit [Ping timeout: 245 seconds]
<beach>
pankajgodbole: It does that, because when the reader sees 'foo, it creates the list (quote foo).
<pankajgodbole>
but (list 'quote 'foo 'bar) evaluates to (quote foo bar)
<beach>
pankajgodbole: That's because the operator QUOTE takes a single argument, so the printer has no abbreviation for that list.
isokee has joined #lisp
<pankajgodbole>
I see
<pankajgodbole>
So Lisp tries to evaluate as much as possible?
<beach>
I don't think so. What makes you say that?
<no-defun-allowed>
Yes, it performs eager evaluation, but I don't think that's got to do with the printer.
<pankajgodbole>
Yes, it appears to perform eager evaluation
robdog has quit [Ping timeout: 252 seconds]
<pankajgodbole>
(quote 'foo) would evaluate to 'foo
<beach>
pankajgodbole: That's not the same as "evaluate as much as possible" though.
<pankajgodbole>
Sorry, I'm missing the right term here
<beach>
"Eager evaluation" is also called "applicative-order evaluation", meaning that for function call, the arguments are all evaluated first. Only then is the function applied to the values of those arguments.
<beach>
So if that is what you meant by "as much as possible", you are right.
<beach>
But, for instance, the result of an evaluation is not evaluated again automatically.
<pankajgodbole>
OK, but (list 'quote 'foo) is evaluated down to 'foo
<beach>
So the value of the expression (list '+ 3 4) is the list (+ 3 4) and not 7.
<pankajgodbole>
and not just to (quote 'foo)
<beach>
Hold on a sec here...
<beach>
pankajgodbole: (list 'quote 'foo) is evaluated as follows:
robdog has joined #lisp
<beach>
LIST is a function, so the arguments are evaluated.
<beach>
The value of 'quote is the symbol quote. The value of 'foo is the symbol foo.
<beach>
Then LIST is called with those values, producing the list (QUOTE FOO)
<beach>
Then the printer sees that list and decides to print it as 'FOO.
<beach>
That's all.
<pankajgodbole>
Oh I see
robdog_ has quit [Ping timeout: 252 seconds]
<pankajgodbole>
I was missing the part where 'foo is evaluated as foo before list is applied to it
<beach>
That's what applicative-order evaluation does.
<beach>
In probably all programming languages you know.
<beach>
Unless you also know Haskell.
<pankajgodbole>
I do know Haskell
<beach>
Oh, OK.
<beach>
Well all the others, then.
<pankajgodbole>
Right
<pankajgodbole>
I'd been using Haskell for some time, most recently
<pankajgodbole>
Thanks
<beach>
Sure.
CuriousCain has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<beach>
pankajgodbole: Feel free to ask other questions. Though for truly newbie questions, and if you have a lot of them, there is #clschool.
<pankajgodbole>
Thank you, beach
<pankajgodbole>
I hope I won't have too many newbie questions :-)
robdog has joined #lisp
<shka__>
pankajgodbole: there is a channel called #clschool where there is no such thing like a too many newbie questions
<shka__>
if you are worried about it
<pankajgodbole>
Great! I'll check it out.
rozenglass has joined #lisp
flamebeard has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
jbb has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
scymtym has joined #lisp
gareppa has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
gareppa has quit [Remote host closed the connection]
isokee has quit [Quit: WeeChat 2.3]
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
flamebeard has quit [Remote host closed the connection]
zigpaw has quit [Quit: Vanishing into darkness in 1..2..3...]
robdog has quit [Read error: Connection reset by peer]
robdog has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 272 seconds]
robdog has quit [Ping timeout: 252 seconds]
esrse has quit [Ping timeout: 246 seconds]
bobby has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
orivej has joined #lisp
edgar-rft has joined #lisp
bobby has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
zigpaw has joined #lisp
robdog has joined #lisp
Volt_ has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 246 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
bgardner has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
eschatologist has quit [Ping timeout: 264 seconds]
Fare has joined #lisp
robdog has joined #lisp
nanozz has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 246 seconds]
dddddd has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Baggers has joined #lisp
robdog has joined #lisp
<Baggers>
what is a good library for pretty printing json? I tried cl-json-util and it doesnt work properly
lavaflow_ has quit [Ping timeout: 246 seconds]
m00natic has joined #lisp
andrei-n has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<d4ryus>
Baggers: not sure if it is a 'good library' but yason can do some pretty printing when 'indent' is specified. http://hanshuebner.github.io/yason/#stream-encoder (with-output takes :indent argument)
<Baggers>
cheers d4ryus I'll give it a go
robdog has joined #lisp
<shka__>
oh, Baggers!
<shka__>
what you are working on? :D
<Baggers>
d4ryus: thankyou that works great. you have spared me from visual studio for a little while :D
robdog has quit [Ping timeout: 252 seconds]
<Baggers>
shka__: adding tags to some asset files that are stored in json
<d4ryus>
Baggers: great :)
Achylles has joined #lisp
robdog has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 255 seconds]
Lord_of_Life_ is now known as Lord_of_Life
robdog has quit [Ping timeout: 252 seconds]
bgardner has quit [Remote host closed the connection]
bgardner has joined #lisp
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
Posterdati has quit [Read error: Connection reset by peer]
robdog has joined #lisp
Posterdati has joined #lisp
polezaivsani has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 245 seconds]
hhdave_ is now known as hhdave
robdog has quit [Ping timeout: 240 seconds]
Achylles has quit [Remote host closed the connection]
robdog has joined #lisp
lumm has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<Baggers>
d4ryus: just a heads up it seems that jason will change false and empty lists to null in some cases.. rather annoying. This happens irrespective of the *parse-json__-as-__* flags
cantstanya has quit [Remote host closed the connection]
<Baggers>
d4ryus: scratch that.. im a muppet and used the flags incorrectly :|
<Baggers>
thanks again for the help
robdog has quit [Ping timeout: 252 seconds]
im0nde_ has quit [Ping timeout: 252 seconds]
scymtym has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
im0nde_ has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<d4ryus>
Baggers: ah, good. Thought that there where options to change how stuff gets parsed, but its quite some time ago that i used yason.
robdog_ has quit [Ping timeout: 252 seconds]
im0nde_ has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
Achylles has joined #lisp
warweasle has joined #lisp
robdog has joined #lisp
wxie has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
DGASAU has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
lucasb has joined #lisp
<beach>
jackdaniel: Is the ECL build procedure documented somewhere?
xkapastel has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
sjl_ has quit [Quit: WeeChat 2.3-dev]
<Xach>
beach: i built ecl yesterday with ./configure && make.
<beach>
Xach: I am not looking to build it. I am preparing my ELS talk on bootstrapping, and I wanted to have a short presentation about how a Common Lisp system written in some other language is bootstrapped.
<Xach>
ok. i figured it was something more complex but the word "build" is ambiguous.
<beach>
Oh, indeed. Sorry.
sjl_ has joined #lisp
<jackdaniel>
beach: it is not, but I can tell you about it
<splittist>
What could me more self-describing than autoconf (:
<jackdaniel>
splittist: autoconf supported by automake and custom substitution scripts?
<beach>
jackdaniel: That would be great, if it is not too much work for you.
<splittist>
(:
<beach>
Perhaps you could use what you tell me as the basis of such a document.
<jackdaniel>
sure. it works as follows: first ecl_min is built (which is a very basic lisp-2 written only in C, part of it is bytecodes compiler and threaded interpreter of forth-like stack bytecode), then lisp sources are loaded into it one by one towards complete common lisp
<jackdaniel>
(clos is loaded as the last "common lisp" module - it is based on pcl)
<jackdaniel>
after that compiler is loaded (common lisp program which compiles to C and invokes C compiler)
<jackdaniel>
when we have compiler, ecl compiles its sources by linking libeclmin.a (same code used to build ecl_min binary) and compiled lisp files into shared library libecl.so
<jackdaniel>
after that we build ecl binary which is a mere client of libecl.so
nanoz has joined #lisp
<jackdaniel>
contrib modules are built in a similar manner to fasl files (native fasl files are in fact shared libraries too)
robdog has joined #lisp
<jackdaniel>
of course this is the most common variant, it is possible to build libecl.a (static library) etc
<jackdaniel>
is this clear enough, or you need more details / have questions?
<beach>
jackdaniel: Thanks. I'll digest this information and get back to you if I need more.
<jackdaniel>
sure
robdog has quit [Ping timeout: 252 seconds]
wxie has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
choiboi has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
Inline has joined #lisp
phlm has joined #lisp
scymtym has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<choiboi>
How free is SBCL? Like does GNU approve?
<beach>
Yes.
<beach>
Public domain as I recall.
<la_mettrie>
public domain and BSD/MIT licenses
dreamcompiler has joined #lisp
marcoecc has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
rippa has joined #lisp
dreamcompiler has quit [Quit: dreamcompiler]
dreamcompiler has joined #lisp
q9929t has joined #lisp
robdog has joined #lisp
dreamcompiler has quit [Client Quit]
paul0 has quit [Remote host closed the connection]
rumbler31 has quit [Remote host closed the connection]
akater has quit [Quit: WeeChat 2.3]
q9929t has quit [Quit: q9929t]
robdog has quit [Ping timeout: 252 seconds]
rumbler31 has joined #lisp
<zigpaw>
some countries doesn't recognize public domain as a valid legal licensing scheme (afair - germany).
<zigpaw>
not sure what implication this might have.
lavaflow_ has joined #lisp
Fare has quit [Ping timeout: 246 seconds]
Jesin has quit [Quit: Leaving]
robdog has joined #lisp
phlm has quit [Quit: WeeChat 2.4]
Tristam has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
<TMA>
zigpaw: you need to find an american to take it from the public domain and license it under CC0. be sure the chosen american is a citizen, not underage or otherwise limited in their ability to perform legally binding actions and that he is physically present in the USA at the time of such license issual
Tristam has joined #lisp
<TMA>
also, this is not a legal advisory, just some wild guess as to what needs to be done to feed the lawyers so they don't bite us
<TMA>
I am not sure of the corner cases where the country might honor berne conventions but not recognize any of the common-law countries
Jesin has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
fortitude has quit [Remote host closed the connection]
<splittist>
The time and effort spent by folks on the internet worrying about software licences dwarfs the actual time and effort spent on software licence litigation - and in this I count all the Google/Oracle/Apple/Microsoft etc stuff. It is the ultimate premature optimization...
<splittist>
imho, ianyl etc.
<aeth>
on the other hand, the wrong software license will get people to immediately close the tab on your github page (or, far more rarely, get people using your software in ways you didn't anticipate and don't want)
<verisimilitude>
I just use the CC0 in the few cases I don't want to use the AGPLv3.
cage_ has joined #lisp
<verisimilitude>
What's worst, splittist, is the attitude of ``Don't worry about licenses, but don't use the GPL either; if you don't want to worry, use a permissive license as the default, instead!''.
robdog has joined #lisp
<aeth>
It's a simple tradeoff. The more permissive the license, the more contributors/users you get at the risk of having users you don't want. This is more of an issue in practice with CC licenses for media, where corporations will misuse your images all of the time.
<aeth>
Seen that way, it's no surprise in the Github world of programming for exposure that it's mostly MIT licensed.
<verisimilitude>
If you don't care, you should probably use the AGPLv3, since you can very easily drop rights with a more permissive license, but can't regain any.
<verisimilitude>
Also, I'm skeptical of the claim you get more people with a permissive license.
<aeth>
But you can "regain". If you are the primary developer, and you're continuously productive (or working on a project that needs continuous updates), and you control the upstream, you can relicense it later on (although it might not be popular) and what are people going to do?
<verisimilitude>
I figure people are usually encouraged to use permissive licenses because that makes them corporate tools far more easily than a copyleft license.
robdog has quit [Ping timeout: 252 seconds]
<verisimilitude>
You can't regain it on any currently released version, aeth, although if you're constantly making changes you could change the license, sure, and there are large projects that have done so successfully.
<aeth>
You only really get successful forks if the relicenser is Oracle
<aeth>
although, actually, did Oracle relicense any of them or just started neglecting them? not sure
<beach>
splittist: It looks like #lisp is contributing to the time and effort you were referring to.
<verisimilitude>
I'm not worrying about it, beach.
schweers has quit [Ping timeout: 240 seconds]
<aeth>
verisimilitude: I suspect you see permissive because most FOSS these days is in tools or libraries and permissive is simpler to deal with in a multilingual, mostly-not-C environment than LGPL.
robdog has joined #lisp
<splittist>
beach: indeed. I was going to compare the length of the logs about licences, to those about non-licence discussion. I guess it's relatively harmless displacement activity, albeit definitely off-topic by now. (And this is meta-off topic...)
Fare has joined #lisp
<verisimilitude>
We can discuss what we're working on in Lisp, then.
<verisimilitude>
I've been playing with Gopher lately; I have a Gopher map parser in eight lines of Common Lisp, although I'd prefer to make it smaller.
nullheroes has quit [Quit: WeeChat 1.9.1]
rumbler31 has quit [Remote host closed the connection]
<verisimilitude>
I suppose capping the size at one hundred or preferably fifty lines would be more than enough to fit everything that would be worthwhile in the library.
robdog has quit [Ping timeout: 240 seconds]
nullheroes has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<jackdaniel>
I'm working on an interactive documentation examiner and writer called "London" (in CLIM)
<jackdaniel>
also I've resumed work on Matroska build system
CuriousCain has quit [Quit: WeeChat 2.2]
<splittist>
jackdaniel: cool. Is London anything like Concordia?
bilb_ono has joined #lisp
<jackdaniel>
splittist: I don't know what Concordia is
<splittist>
jackdaniel: it was the Genera documentation writing system.
<jackdaniel>
it is a result of my constant dissatisfaction with texinfo, docbook, latex, markdown and similar solution
<jackdaniel>
I saw Genera's Documentation Examiner on a video and I've liked it
<beach>
Two interesting observations: 1. The dress code at the time, and 2. The slowness of Genera.
pankajgodbole has quit [Ping timeout: 272 seconds]
jxy has quit [Ping timeout: 245 seconds]
rozenglass has quit [Remote host closed the connection]
rozenglass has joined #lisp
<splittist>
Almost as slow as gmail...
Fare has quit [Ping timeout: 255 seconds]
pierpal has quit [Read error: Connection reset by peer]
Ukari has joined #lisp
rozenglass has quit [Remote host closed the connection]
rozenglass has joined #lisp
jxy has joined #lisp
pierpal has joined #lisp
orivej has quit [Ping timeout: 250 seconds]
scymtym has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
Fare has joined #lisp
Josh_2 has joined #lisp
rozenglass has quit [Remote host closed the connection]
<jackdaniel>
interesting
<jackdaniel>
some goals overlap
pierpal has joined #lisp
buffergn0me has quit [Remote host closed the connection]
rozenglass has joined #lisp
<jackdaniel>
sorry, I have the little one on one hand
<jackdaniel>
\o
CuriousCain has joined #lisp
varjag has joined #lisp
<sjl_>
cd
<sjl_>
whops
jmercouris has joined #lisp
<jmercouris>
hello everyone
<minion>
jmercouris, memo from fiddlerwoaroof: I've occasionally had build issues on lispworks with serapeum, but I
<minion>
jmercouris, memo from fiddlerwoaroof: never have noticed any real serious problems with it
<jmercouris>
fiddlerwoaroof: I noticed issues when compiling it on SBCL on MacOS, but they were patched literally the next day after I made a report
karlosz has joined #lisp
Arcaelyx has joined #lisp
m00natic has quit [Remote host closed the connection]
varjag has quit [Ping timeout: 252 seconds]
pierpal has quit [Read error: Connection reset by peer]
hhdave has quit [Ping timeout: 246 seconds]
Fare has quit [Ping timeout: 246 seconds]
Fare has joined #lisp
LiamH has joined #lisp
pierpal has joined #lisp
<Josh_2>
huh, my sly won't connect :O
<Josh_2>
just says polling /tmp/sly.2583
<Josh_2>
oof I think I found the problem
<Josh_2>
Fixed, there was a mistake in my .sbclrc
bitmapper has joined #lisp
<bitmapper>
ok, who should i talk to to buy a symbolics machine
<bitmapper>
i've been looking everywhere for a while
karlosz has quit [Quit: karlosz]
eschatologist has joined #lisp
ravenousmoose has joined #lisp
robdog has joined #lisp
<Xach>
bitmapper: that is not a topic of much interest here on #lisp, sorry.
<bitmapper>
what do you mean?
<bitmapper>
i'm not interested in collecting them and having them sit around
<Xach>
bitmapper: I have not observed much discussion of symbolics hardware on #lisp in the past.
<bitmapper>
oh
<bitmapper>
hmm
<Xach>
If I were interested in getting symbolics hardware, I might email Rainer Joswig or Kalman Reti.
<Xach>
But I'm not. I don't care for the noise, slowness, electricity use, bulk, etc. If I really wanted something productive I would try to get the emulated thing (legally).
orivej has joined #lisp
<Xach>
But I'm happy with common lisp and that's the topic of #lisp anyway.
<bitmapper>
I'm happy with lisp too, and I very much enjoy developing in it
robdog has quit [Ping timeout: 252 seconds]
<Xach>
Maybe Gary Palter might know, too. Good luck!
<bitmapper>
thanks!
Oladon has quit [Quit: Leaving.]
robdog has joined #lisp
rozenglass has quit [Ping timeout: 245 seconds]
bilb_ono has quit [Quit: bilb_ono]
robdog has quit [Ping timeout: 252 seconds]
frodef has joined #lisp
ebrasca has joined #lisp
ghard has joined #lisp
robdog has joined #lisp
Zaab1t has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
scymtym has quit [Ping timeout: 252 seconds]
SaganMan has joined #lisp
jmercouris has quit [Remote host closed the connection]
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
lemoinem has quit [Ping timeout: 255 seconds]
<beach>
bitmapper: You may then consider helping out with developing McCLIM as a step in the direction of recreating the excellent environment of Genera.
<verisimilitude>
I emailed that Symbolics email and have yet to get a reply, bitmapper.
<bitmapper>
i emailed them a while ago
<bitmapper>
they did reply to me
eddof13 has quit [Ping timeout: 252 seconds]
<bitmapper>
the only machine they had at the time was a macivory iii though
Fare has quit [Ping timeout: 272 seconds]
robdog has joined #lisp
techquila has joined #lisp
izh_ has joined #lisp
<bitmapper>
i would use mcclim if i could get it working
robdog has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Remote host closed the connection]
<jackdaniel>
bitmapper: what is your operating system?
<bitmapper>
nixos
robdog has joined #lisp
<bitmapper>
but the issue is with the xxauthority file
<jackdaniel>
so Linux. If you use quicklisp just type: (ql:quickload 'clim-examples) followed by (clim-demo:demodemo)
<jackdaniel>
ah, what kind of issue?
buffergn0me has joined #lisp
<verisimilitude>
How long ago, bitmapper?
robdog has quit [Ping timeout: 240 seconds]
<verisimilitude>
Which address did you email, in particular?
<bitmapper>
it was about 6 months ago
<bitmapper>
verisimilitude: i emailed the one on symbolics-dks
<bitmapper>
jackdaniel: end of file error on Xauthority
<verisimilitude>
I emailed them more recently than that and yet received no response; how queer.
cage_ has quit [Remote host closed the connection]
<verisimilitude>
Perhaps they thought it was spam.
robdog has joined #lisp
ym555 has joined #lisp
mathrick has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
vlatkoB has quit [Remote host closed the connection]
robdog has joined #lisp
mathrick has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 268 seconds]
brettgilio has quit [Read error: Connection reset by peer]
robdog has joined #lisp
bilb_ono has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
nanoz has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
warweasle has quit [Quit: later dudes]
<no-defun-allowed>
I did get a response, and I'm on DKS's lispm-selling list.
Selwyn has joined #lisp
rumbler31 has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
jmercouris has joined #lisp
<bitmapper>
what's that mean no-defun-allowed
<no-defun-allowed>
I did get a response from symbolics.
<bitmapper>
I meant the lispm-selling list thing.
jmercouris has quit [Remote host closed the connection]
<no-defun-allowed>
He put me on a mailing list which he announces sales of Lispms on.
robdog has joined #lisp
<no-defun-allowed>
The last one I recall was a MacIvory machine.
bitmapper has quit [Ping timeout: 255 seconds]
igemnace has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 252 seconds]
igemnace has joined #lisp
ebrasca has quit [Remote host closed the connection]
akoana has joined #lisp
robdog has joined #lisp
z3t0 has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
robdog has joined #lisp
robdog has quit [Read error: Connection reset by peer]
robdog has joined #lisp
anamorphic has joined #lisp
angavrilov has quit [Remote host closed the connection]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Achylles has quit [Remote host closed the connection]
robdog_ has quit [Ping timeout: 252 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
verisimilitude has quit [Remote host closed the connection]
Achylles has joined #lisp
ravenousmoose has joined #lisp
robdog has joined #lisp
anamorphic has quit [Quit: anamorphic]
buhman has quit [Ping timeout: 244 seconds]
q3d has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
akater has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
okeg has joined #lisp
<fouric>
beach: i set several different optimization settings in my .sbclrc, then loaded alexandria and disassembled COPY-HASH-TABLE. the resulting disassembly was the same size for (speed 0), (speed 3), and (space 3)
<fouric>
...and, in previous experiments with one of my own systems, neither proclaim nor sb-ext:restrict-compiler-policy had any effect on the size of disassembled functions, unless i manually set those optimization settings and then explicitly recompiled the function
<fouric>
oh, i guess quicklisp is trying to be smart and not recompile _everything_ on my system if i change the optimization settings.
q3d has quit [Ping timeout: 256 seconds]
micro has quit [Ping timeout: 255 seconds]
jack_rabbit_ has joined #lisp
<fouric>
yup, i just need to remove the compiled FASLs
<Xach>
quicklisp defers to asdf for things like that. quicklisp fetches and unpacks things and tells asdf to compile & load things
<fouric>
that makes sense
<jackdaniel>
true story, if you fake enough interfaces from asdf ql works with it just fine
<fouric>
would you happen to know off the top of your head if there's a way to tell ASDF to re-compile all files associated with a system?
<Xach>
fouric: :force t, or something, but i think that does too much by default?
micro has joined #lisp
<Xach>
it recompiles all deps too
<fouric>
oh, and i wanted to avoid that
<fouric>
oh well, i'll read the docs or something later
robdog has joined #lisp
<aeth>
jackdaniel: Faking ASDF interaces as in, e.g., a hypothetical Makefile-QL bridge without ASDF as an intermediate?
Bike has quit []
<aeth>
If that's the case, I look forward to using a Quicklisp repository for ECL. :-)
<aeth>
Or more generally, as a distro package manager, at least if encryption is added first.
robdog has quit [Ping timeout: 252 seconds]
andrei-n has quit [Remote host closed the connection]
<Xach>
i have the code and must get it out to The People
<aeth>
It would be nice to have a Lisp-driven package manager, either standalone or working with Quicklisp and/or ASDF. It would mean lighter VMs assuming you're using a cloud service that allows custom Linux distro images. Well, maybe not lighter, but more aimed at deploying Lisp server applications.
<xantoz>
guix? (scheme, but close enough)
eddof13 has joined #lisp
<aeth>
Well... Most distros have a very stale SBCL and many don't include CCL. This sort of package manager could have a stable and a current for each Lisp, sort of like roswell but not 25% C (with all of the bugs C causes) because it wouldn't need to assume a Lispless system to bootstrap on.
<aeth>
So more Roswell than Guix
<jackdaniel>
aeth: I've implemented a simple asdf-compat layer for matroska some time ago
mange has joined #lisp
<jackdaniel>
and it made my custom definitions work for ql
<aeth>
I did some basic text work myself and will have to do more when I get back to it in a little while, it is not easy. (This is for OpenGL text, so it's a different use case, although nothing stops CLIM from targeting it as a backend.)
<aeth>
In fact, I'd probably say that text rendering is probably the hardest of the easy-looking things. (Text looks so easy because it's everywhere, even at the most basic levels of introductory programming.)
izh_ has left #lisp [#lisp]
iovec has quit [Quit: Connection closed for inactivity]
vhost- has joined #lisp
q3d has joined #lisp
robdog has joined #lisp
okeg has quit [Quit: WeeChat 1.6]
robdog has quit [Ping timeout: 252 seconds]
wxie has joined #lisp
eschatologist_ has joined #lisp
jbb has joined #lisp
eschatologist has quit [Ping timeout: 264 seconds]
bilb_ono has joined #lisp
<polezaivsani>
cl 101 - setq for an unbound variable seem to be introducing a new binding for a global variable. is it correct? standard?
<Xach>
polezaivsani: no and no
Baggers has quit [Remote host closed the connection]
jbb_ has joined #lisp
polezaivsani has quit [Ping timeout: 245 seconds]
jbb has quit [Ping timeout: 255 seconds]
<fiddlerwoaroof>
Interestingly, my Debian box has a fairly reasaoable sbcl version in the os repositories
karlosz has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
karlosz has quit [Client Quit]
robdog has joined #lisp
<fiddlerwoaroof>
1.4.11 which comes from August 2018
karlosz has joined #lisp
okeg has joined #lisp
q3d has quit [Ping timeout: 256 seconds]
<aeth>
I'm surprised.
robdog has quit [Ping timeout: 252 seconds]
techquila has quit [Remote host closed the connection]
wxie has quit [Ping timeout: 252 seconds]
LiamH has quit [Quit: Leaving.]
frodef has quit [Ping timeout: 255 seconds]
robdog has joined #lisp
Bike has joined #lisp
karlosz has quit [Quit: karlosz]
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
techquila has quit [Max SendQ exceeded]
quazimodo has joined #lisp
ghard has quit [Remote host closed the connection]
techquila has joined #lisp
polezaivsani has joined #lisp
dgi has quit [Ping timeout: 246 seconds]
<polezaivsani>
if somebody chimed in to my 101 - could you please repeat it for i had network issues
eschatologist_ is now known as eschatologist
<aeth>
polezaivsani: if you're more familiar with C-like languages... (setq foo 42) and (setf foo 42) are like "foo = 42;" whereas defvar/defparameter/let/let*/etc. are like "var foo = 42;" or "int foo = 42;"
<polezaivsani>
thanks, aeth. i get that mostly, although i'm deliberately trying to avoid comparison with c as it hadn't been that productive for me.
<aeth>
Afaik (and I could be wrong... the documentation pages for SETQ and SETF don't seem to mention it), if an implementation sees a setq without a variable binding, it's undefined so it doesn't know where to put it: in the global (dynamic) scope, in the most local lexical scope, or wherever else it feels like putting it. Implementations generally put it as the global if it's valid afaik.
<aeth>
s/if it's valid/if the implementations treat it as valid/
<aeth>
s/scope/environment/
<polezaivsani>
i haven't found an explanation for such behaviour in the standard
<polezaivsani>
not that i plan on used it really though
polezaivsani has left #lisp ["ERC (IRC client for Emacs 26.1)"]
<aeth>
This part is a bit confusing for people not used to the language because there are two kinds of environments: dynamic/special and lexical. Most old languages were just dynamic, most new languages are just lexical. Few mix the two. Of course Perl does this, though. What feature doesn't Perl have?
polezaivsani has joined #lisp
<aeth>
polezaivsani: This part is a bit confusing for people not used to the language because there are two kinds of environments: dynamic/special and lexical. Most old languages were just dynamic, most new languages are just lexical. Few mix the two. Of course Perl does this, though. What feature doesn't Perl have?
robdog has joined #lisp
<aeth>
Portably, globals are dynamic but there are other globals that can exist in implementation-specific ways (and that might or might not be portable enough to have a portability library). By default, locals are lexical but can be declared special (dynamic).
<aeth>
And this is why implicit globals you're unaware of even creating (via setq) are especially problematic in Common Lisp. The first call to (foo) accidentally creates a global qwerty in some implementations, which is returned as the second value: (defun foo () (setq qwerty 42)) (values (foo) qwerty)
<aeth>
(The values is top level so the qwerty is top level. I just put it in a form so it would also display the return value of calling foo)
<polezaivsani>
i swear, i won't be doing random setq in code beyond my scratchpad) i just try to prod at whatever issue i bump into in pursuit of better understanding
<aeth>
It's fine in REPL use, but SBCL seems to give a 10-line warning each time so that might remove some of the convenience.
<aeth>
defparameter is a decent alternative because it will behave as you expect, redefining it each time. (defvar only defines it if it's undefined)
robdog has joined #lisp
<polezaivsani>
while at it, do global/dynamic variable bindings belong to dynamic env?
<fiddlerwoaroof>
aeth: the trick is to run debian testing, which is about as stable as ubuntu LTS releases :)
robdog has quit [Ping timeout: 252 seconds]
<polezaivsani>
nermind the last one, i'll rtfm first
<aeth>
polezaivsani: It looks like global dynamic variable bindings are in both the global and dynamic environments, but there are things that are only in the global environment (like function bindings) and things that are only in the dynamic environment (like restarts or, I think, local variables declared special)
<aeth>
yes, it's in the section of tfm I linked to