nullman has quit [Remote host closed the connection]
charles` has quit [Ping timeout: 264 seconds]
wxie has quit [Ping timeout: 260 seconds]
nullman has joined #lisp
iskander has quit [Ping timeout: 272 seconds]
epony has quit [Ping timeout: 240 seconds]
iskander has joined #lisp
pankajsg has joined #lisp
epony has joined #lisp
gitgood has quit [Ping timeout: 260 seconds]
wxie has joined #lisp
toorevitimirp has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 246 seconds]
aeth has joined #lisp
gzj has joined #lisp
landakram has joined #lisp
ldbeth has quit [Read error: Connection reset by peer]
nicktick has quit [Ping timeout: 272 seconds]
thmprover has quit [Quit: ...and miles to go before I sleep.]
nicktick has joined #lisp
nicktick has quit [Ping timeout: 246 seconds]
cchristiansen has joined #lisp
nicktick has joined #lisp
asarch has joined #lisp
gioyik_ has joined #lisp
gioyik has quit [Ping timeout: 268 seconds]
gioyik_ has quit [Read error: Connection reset by peer]
nicktick has quit [Ping timeout: 260 seconds]
waleee-cl has quit [Quit: Connection closed for inactivity]
gioyik_ has joined #lisp
GZJ0X_ has joined #lisp
gzj has quit [Remote host closed the connection]
estest has joined #lisp
nicktick has joined #lisp
<lukego>
I've been trying to pick a unit testing framework. Just makes my head hurt with all the options and trying to interpret the reviews over time. Going to try 1am to start with.
narimiran has joined #lisp
<beach>
My theory is that the idea of an abstraction such as a "unit testing framework" is nonsensical, and that this is why there are so many of them and none of them can do everything that is needed.
<beach>
Take Flexichain, for instance. With most testing frameworks, I would have had to enumerate all possible situations, but the number of combinations that can happen between resizing, rotation, moving the gap is truly huge, and it would not be humanly possible to figure that out manually so that every combination is tested.
egp_ has joined #lisp
egp__ has joined #lisp
skapata has quit [Remote host closed the connection]
<beach>
So instead, I wrote a trivial implementation of the same protocol, and I generate random operations using sort of a first-order Markov model.
<lukego>
Yeah. I'm thinking of starting with a combo of a dumb/convenient test-runner that can then call into a more "combinatorial" kind of a test case generator. I was thinking check-it but leaning towards just giving Screamer <duration> to find a bad case
<beach>
I then compare the result of the trivial implementation to the result of the real one.
<beach>
That way, I can test a gazillion combinations with only a page of testing code.
<beach>
And i memorize the sequence so that, if there is a bug, I can reproduce it.
<beach>
OK, so now give me the name of a testing framework that would give me support for this way of testing things, which I find way superior to enumerating individual tests maually.
<beach>
manually
<beach>
Oh, there isn't any? I guess I will have to write my own then, right?
<lukego>
well that's basically what quickcheck/check-it is about, right?
<beach>
I don't know. I use ASSERT.
<beach>
ASSERT is an excellent testing framework that has the additional advantage that it is in the Common Lisp standard.
nmg_ has joined #lisp
<fiddlerwoaroof>
lukego: fwiw, I just use 5am these days
nmg has quit [Ping timeout: 272 seconds]
<fiddlerwoaroof>
But, I'm more interested in "oracle" tests: for the sort of code I write, I don't usually care if the tests are exhaustive as long as they run quickly and cast common mistakes I make when I write code.
<fiddlerwoaroof>
s/cast common mistakes/catch common mistakes/
shka_ has joined #lisp
TMA has quit [Ping timeout: 240 seconds]
<pyc>
Was there some quote about some language which said something like it makes easy problems easy and difficult problems possible to solve? Anyone remembers in what context or where this quote was said?
iskander- has joined #lisp
varjag has joined #lisp
asarch has quit [Quit: Leaving]
<jackdaniel>
the context was: lisp is a language where easy problems are trivial to solve, and hard problems are possible to solve (in contrast to easy problems are hard and hard problems are impossible to solve in /some/ languages)
<jackdaniel>
I don't remember where it came from though
iskander has quit [Ping timeout: 240 seconds]
bilegeek has quit [Quit: Leaving]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
vutral_ has joined #lisp
<lukego>
beach: that's how check-it is supposed to work. you define generators for test data (e.g. sequences of editing operations) and invariants that must hold (e.g. model and real impl return same results.) then it makes a randomized search for inputs that fail. if it finds a failure then it moves on to "shrinking" i.e. trying to find a smaller version of the failing input (e.g. smaller numbers, shorter lists, etc)
<lukego>
beach: but check-it doesn't seem to have the "assert" part of testing. So you'd still need some way to organize tests e.g. give them names and have a way of running some/all of them. and 1am seems like a reasonable solution to that - just a page of code where a test is a function that's registered on the *tests* list.
fitzsim has quit [Remote host closed the connection]
<lukego>
... and if I'm doing generator-driven testing then I'm also asking myself whether to use check-it, which is a relatively simple implementation tailored specifically for test-case generation, or Screamer, being more complex and more general (but potentially less suitable e.g. in how it navigates the search space)
zooey_ has joined #lisp
zooey has quit [Ping timeout: 268 seconds]
<pyc>
jackdaniel: found the exact quote. I read it in Practical Common Lisp. It is in chapter 1. >> Perl advocates like to say that Perl "makes easy things easy and hard things possible" and revel in the fact that, as the Perl motto has it, "There's more than one way to do it."
<jackdaniel>
ah, thanks
<beach>
lukego: Interesting. Thanks!
aartaka has joined #lisp
epony has quit [Remote host closed the connection]
<lukego>
beach: this kind of "differential testing" you describe does sound pretty great to me. if you have two implementations and reason to believe they won't have the *same* bugs then it stands to reason that you can compare them to shake the bugs out of both.
ljavorsk has joined #lisp
<lukego>
fiddlerwoaroof: thanks for the datapoint. 5am does seem like a safe option. I'm a bit cautious just because it seems like quite a bit of code and probably a lot that doesn't apply to me e.g. I'm not connecting to databases and stuff
Cymew has joined #lisp
<lukego>
Hey if you wanted to check if all the strings in a list were the same length would it seem natural to write (all #'= #'length strings)? or what's idiomatic lisp for that?
luni has joined #lisp
<beach>
lukego: Exactly. It is highly unlikely that the two would behave in the same incorrect way. And since one is trivial (it is an "editable sequence" implemented as a list) it is already highly unlikely that that one will be incorrect in the first place.
nullx002 has joined #lisp
varjag has quit [Ping timeout: 256 seconds]
pve has joined #lisp
xvzf has joined #lisp
<lukego>
I think I'll keep it stupid and write (apply #'= (mapcar #'length strings)) because ALL sounds like such a serious function name and I'd have to think too much about how it relates to existing functions like EVERY.
landakram has quit [Disconnected by services]
<lukego>
Hey cool if there were a website like compiler explorer that would let you write a fragment of code, e.g. CALL-ARGUMENT-LIMIT, and shows you what it evaluates to in all major lisps
<lukego>
(or maybe a nix expression to do that would be easier except for licensing issues)
landakram has joined #lisp
<lukego>
(or maybe just stick with sbcl)
<jdz>
lukego: I seem to remember Fare's CL launcher script had this as an example case.
<jdz>
lukego: But you'd have to have all the implementations installed.
nullx002 has quit [Ping timeout: 246 seconds]
<jdz>
I'm both impressed and afraid of the cl-launch itself, though.
<lukego>
maybe Nix could handle that part. but it's not really an urgent problem for me, I'm not trying to write especially portable code, I just have a voice in my head saying "CALL-ARGUMENT-LIMIT" when I write things like (apply #'= ...)
<jdz>
lukego: Which should immediately trigger the "can't I use REDUCE, though?" question in your brain.
zaquest has quit [Quit: Leaving]
xvzf has quit [Quit: Connection closed]
<jackdaniel>
or (every (curry #'= (first args)) (rest args))
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
<easye>
That's some hot curry there...
surabax has joined #lisp
attila_lendvai has joined #lisp
epony has joined #lisp
aeth has quit [Ping timeout: 256 seconds]
bitmapper has quit [Quit: Connection closed for inactivity]
aeth has joined #lisp
zaquest has joined #lisp
<lukego>
oh I like the curry solution. I'm not sure how the REDUCE would look just because there are kinda two accumulators i.e. truthiness and target length
<jdz>
Yes, in this case REDUCE fails.
<lukego>
maybe some kind of (reduce #'assert= strings :key #'length) but unlikely to be the simplest solution
<fiddlerwoaroof>
lukego: you can put the two accumulators in a datastructure of some kind. e.g. (list acc1 acc2) or something
<lukego>
(= (reduce #'min strings :key #'length) (reduce #'max strings :key #'length)) but now I'm just being silly.
<jdz>
In my opinion (every #'= (mapcar #'length ...)) is OK.
anticrisis has quit [Quit: Leaving]
aartaka_d has joined #lisp
<jdz>
I'd look for other solutions if performance matters (i.e., target list may be long).
<lukego>
I'm mostly thinking of the norvig/pitman "rule of english translation." I want to check that "strings all have equal length." so (all-equal-length strings) would be good but that's a whole function. (all #'equal #'length strings) would be fine except that such an ALL function doesn't exist.
<lukego>
but, meta-solution, the real problem here is that I feel a lot of pressure to keep my unit test code hyper-concise so that it doesn't distract from the actual implementation code, but I'll solve that by just putting it in another file and letting it grow as much as it needs to.
aartaka has quit [Ping timeout: 240 seconds]
hiroaki_ has quit [Ping timeout: 272 seconds]
<lukego>
that feels better already.
<lukego>
I actually enjoy this kind of obsessing about Lisp programming. it seems like one of the few languages where you can actually get value out of it. the returns may be diminishing but there's *is* always a better way that you can find...
totoro2021 has quit [Read error: Connection reset by peer]
totoro2021 has joined #lisp
<jdz>
The test of the machine is the satisfaction it gives you. There isn't any other test. If the machine produces tranquillity it's right. If it disturbs you it's wrong until either the machine or your mind is changed. The test of the machine's always your own mind. There isn't any other test. — Robert M. Pirsig, Zen And The Art Of Motorcycle Maintenance
pagnol has joined #lisp
<lukego>
Great quote. Pity about the whole descent-into-madness connotation but I'll take it :)
orivej has joined #lisp
hiroaki_ has joined #lisp
surabax has quit [Quit: Leaving]
fouric has quit [Ping timeout: 240 seconds]
fouric has joined #lisp
xvzf has joined #lisp
landakram has quit [Remote host closed the connection]
<lukego>
I'd quite like to adopt using CURRY but it seems like I'll often want to curry things that are macros rather than functions. The nearest solution that comes to mind is Serapeum's OP macro.
<lukego>
like I was happy with a test case (every #'is *valid-examples*) but then how to test *invalid-examples* not as (is E) but (signals error E)
<lukego>
where signals is a macro
<lukego>
though my first example is a bit weird, calling EVERY for side effects, since #'is does an assertion
fouric has quit [Ping timeout: 260 seconds]
* lukego
is in exactly the right frame of mind for cruising serapeum docs...
<lukego>
(oh ahem and 1AM:IS is actually also a macro and not a function)
heisig has joined #lisp
fouric has joined #lisp
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
xvzf has quit [Quit: Connection closed]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
nicktick has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
vutral_ has quit [Quit: Connection closed for inactivity]
karlosz has quit [Quit: karlosz]
galex-713 has quit [Ping timeout: 272 seconds]
GZJ0X_ has quit [Read error: Connection reset by peer]
GZJ0X_ has joined #lisp
<lukego>
So I'm not really satisfied with with LOOP nor with classics like DOLIST. Is ITERATE the only other real game in town?
<jackdaniel>
(defmacro do-bi-do-bi-da (…) `(do …)) ; utlimate game in town
ukari has quit [Remote host closed the connection]
<beach>
lukego: LOOP is fine for most cases. What problem do you have with it? I mean, it has the advantage of being in the standard, so that no external dependency is needed.
<heisig>
lukego: There is also the series package. And plain old recursion :)
<lukego>
SERIES does CPS though right, or am I mixing it up with Screamer? I want to keep the bulk of my code compatible with the SLIME debugger
<lukego>
beach: Yeah. I'd usually use LOOP but pn this project I'm okay with taking on dependencies and being a bit idiosyncratic. I'm having two common issues with loop -
<pranavats>
I don't think SERIES provides any equivalent of continuations.
<lukego>
One is code moving towards the right margin of the screen. Maybe though this is me not taking full advantage of the quirks of the Emacs indentation of LOOP somehow.
<lukego>
The other is having to nest loops - causing more indentation - when I want to iterate not in parallel but as in (dotimes (y height) (dotimes (x width) ...)) when e.g. "list comprehensions" kind of abstractions would do that in one go
<beach>
lukego: The clauses should be aligned. If not something is wrong.
<beach>
lukego: I also find myself saving indentation by introducing a FOR clause, using it as a LET*.
<lukego>
I basically want to have two spaces of indentation in the bodies of my loops, in the spirit of &body, but that's not always easy to get with LOOP.
<beach>
Yeah, I can't help you with that.
<lukego>
This FOR macro linked above ^ seems to have a neat solution to that i.e. having a more LET-style syntax
<fiddlerwoaroof>
It's completely undocumented so far, but I really like transducers for this: you right your code with functions like MAPCAR/REMOVE-IF-NOT but you skip all the intermediate lists
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
attila_lendvai_ has joined #lisp
edgar-xyz has joined #lisp
contrapunctus has joined #lisp
wxie1 has joined #lisp
madnificent_ has joined #lisp
penguwin5 has joined #lisp
Oladon1 has joined #lisp
jurov_ has joined #lisp
t3hyoshi_ has joined #lisp
datajerk_ has joined #lisp
herlocks- has joined #lisp
Cthulhux` has joined #lisp
markasoftware_ has joined #lisp
justinmcp_ has joined #lisp
dwts_ has joined #lisp
froggey_ has joined #lisp
aeth_ has joined #lisp
guaqua_ has joined #lisp
engblom_ has joined #lisp
hiredman_ has joined #lisp
luis6 has joined #lisp
SAL9000_ has joined #lisp
jxy_ has joined #lisp
sukaeto1 has joined #lisp
yCrazyEdd has joined #lisp
phantomics_ has joined #lisp
Lord_of_Life_ has joined #lisp
ramus_ has joined #lisp
acolarh_ has joined #lisp
xlei_ has joined #lisp
kevingal has joined #lisp
kevingal_ has joined #lisp
aeth has quit [*.net *.split]
attila_lendvai has quit [*.net *.split]
wxie has quit [*.net *.split]
pankajsg has quit [*.net *.split]
pve has quit [*.net *.split]
vegansbane6963 has quit [*.net *.split]
SAL9000 has quit [*.net *.split]
CrazyEddy has quit [*.net *.split]
jprajzne has quit [*.net *.split]
froggey has quit [*.net *.split]
dwts has quit [*.net *.split]
Lord_of_Life has quit [*.net *.split]
madnificent has quit [*.net *.split]
engblom has quit [*.net *.split]
ramus has quit [*.net *.split]
luis has quit [*.net *.split]
datajerk has quit [*.net *.split]
jxy has quit [*.net *.split]
jurov has quit [*.net *.split]
penguwin has quit [*.net *.split]
edgar-rft has quit [*.net *.split]
phantomics has quit [*.net *.split]
thecoffemaker has quit [*.net *.split]
markasoftware has quit [*.net *.split]
Cthulhux has quit [*.net *.split]
t3hyoshi has quit [*.net *.split]
Oladon has quit [*.net *.split]
acolarh has quit [*.net *.split]
xlei has quit [*.net *.split]
guaqua has quit [*.net *.split]
herlocksholmes has quit [*.net *.split]
justinmcp has quit [*.net *.split]
hiredman has quit [*.net *.split]
sukaeto has quit [*.net *.split]
Lord_of_Life_ is now known as Lord_of_Life
penguwin5 is now known as penguwin
luis6 is now known as luis
xlei_ is now known as xlei
thecoffemaker_ has joined #lisp
yCrazyEdd is now known as CrazyEddy
wxie1 is now known as wxie
<lukego>
I'm actually fine with having lots of intermediate lists, I'm mostly looking for something that feels a bit poetic.
vegansbane6963 has joined #lisp
<lukego>
heisig: Thanks for the reminder of plain old recursion :). That's how I'd write e.g. Scheme code quite happily. Maybe with serapeum macros like NLET and COLLECTING that can be poetic too.
zmv- has quit [Ping timeout: 264 seconds]
rme has quit [Ping timeout: 264 seconds]
rme has joined #lisp
jonatack has joined #lisp
SAL9000_ is now known as SAL9000
<lukego>
though NLET has this weird tail-position-only restriction and using ordinary recursion risks creating big control stacks that are boring to look at in the debugger.
<lukego>
food for thought on a dog walk...
Nilby has joined #lisp
pve has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
contrapunctus has joined #lisp
phantomics_ has quit [Quit: Ex-Chat]
phantomics has joined #lisp
galex-713 has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` is now known as X-Scale
wxie has quit [Ping timeout: 256 seconds]
xvzf has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 256 seconds]
kam1 has joined #lisp
<lukego>
Hey what's a neat way to write (cdr (assoc key a-list)) such that it errors when the key is not found?
<lukego>
first thought was (assert (cdr (assoc key a-list))) but assert returns nil
aeth_ has quit [Ping timeout: 246 seconds]
<Nilby>
I might just say (or ... (error ...))
aeth has joined #lisp
<lukego>
yeah just a bit wordy
<lukego>
could factor it into an assoc function that errors I guess
<beach>
That's the good solution.
X-Scale` has joined #lisp
<lukego>
I'd hoped to find one in serapeum but nearest is assocdr that includes the cdr
<beach>
Nilby's solution violates the expectations according to page 13 of the LUV slides.
<beach>
OR takes Boolean values and the return value of ASSOC is not a Boolean. It is either something useful, or a default value that happens to be NIL.
X-Scale has quit [Ping timeout: 260 seconds]
X-Scale` is now known as X-Scale
<beach>
lukego: Presumably, you want to hide the fact that you have an alist anyway, and present it as a dictionary. Then the protocol function would do the ASSOC and check for NIL.
marcoxa has joined #lisp
<marcoxa>
'(good afternoon)
<fiddlerwoaroof>
You'd need to distinguish NIL as a value of an existing key
<lukego>
This is some low-brow code where I'm happy to be concrete that it's an alist. Though having said that, it's the concreteness I want, not necessarily the a-list. Maybe I can punt and just use a function instead.
<beach>
fiddlerwoaroof: Why?
<lukego>
then ECASE inside the function
<fiddlerwoaroof>
beach: well, if NIL is a valid value for a key, you don't want to error when the key is present but associated with nil
<beach>
Hello marcoxa.
<beach>
fiddlerwoaroof: I think the discussion was about return values and not about keys. Am I wrong?
<fiddlerwoaroof>
I don't think so (assoc :a '((:a . nil))) isn't equivalent to (assoc :a ())?
xvzf has quit [Quit: Connection closed]
<fiddlerwoaroof>
Sorry, "value for a key" is ambiguous, I think
<beach>
fiddlerwoaroof: But NIL is not a key yere.
<beach>
here
<beach>
Oh, you said "value for a key" sorry.
<beach>
Yes, indeed.
<lukego>
(~> text (scan) (parse) (make-object)) ;; I'm enjoying some serapeum indulgence :)
aeth has quit [Ping timeout: 264 seconds]
aeth has joined #lisp
<lukego>
sorry about the rapid-fire but is there any setf-family macro like (updatef str #'string-upcase) ? short for (setf str (string-upcase (getf str)))
<Nilby>
The best use of my advice is to get someone else to tell you the right way.
<lukego>
moon-child: yeah. just wondering there's a reason it doesn't already exist e.g. in alexandria which has maxf/minf/nconcf/etc.
<lukego>
though looking at that code ^ mulitple evaluations of x will be an issue so maybe it's hard
gitgood has joined #lisp
<moon-child>
yes
<lukego>
I'll find another formulation for now
<lukego>
w00t! cache hit! the next thing I was going to ask about already exists in serapeum under the name MAPPLY :)
cosimone has joined #lisp
zmv- has joined #lisp
<splittist>
there's probably a semantically more accurate way of describing what you're doing than UPCASE-PLIST-VALUE-IN-PLACE
vegansbane6963 has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
<lukego>
Yeah. I have a list of lists ((#\X 0 0 1 1) ..) and I want to map that character in the first element position to a longer and more meaningful name e.g. #\X -> :XYLOPHONE.
<lukego>
though I realize that I want to change some of the numbers too and then (mappend (op (ch x0 y0 x1 y1) ...) ...) seems reasonable
<lukego>
also... now that I start accumulating some unit tests it looks an awful lot like design-by-contract... like the tests are mostly just asserting things about the inputs and outputs to functions. maybe I should be using function types instead here.
<lukego>
Can you use declaimed function types for design-by-contract in practice? What do I need to do to get SBCL to promise to check types like this at runtime?
<lukego>
I'll take a look at the DBC library. It would be kind of nice separation of concerns if the implementation if self-testing and the test code mostly just needs to feed it inputs and let it selftest
<lukego>
estest: thanks I didn't know the docs were so good!
<jackdaniel>
but that's true only on sbcl
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<lukego>
that's probably good enough for me
amk has quit [Read error: Connection reset by peer]
amk has joined #lisp
<jackdaniel>
I'm sorry to hear that, I thought that you are writing common lisp ;p
<lukego>
me? never :)
<jackdaniel>
in common lisp*
<lukego>
yeah nah in my own application code I prefer to limit the number of variables, e.g. platforms and compilers, to as narrow as possible. I'm not writing libraries for other people here.
<lukego>
and I suppose that I _am_ writing common lisp code if I specify the detailed types of my key functions using Common Lisp type declarations, it's not my fault if some compilers choose to ignore that :)
<jackdaniel>
declare is described in the standard as a "promise to the compiler", not a safety measure
<jackdaniel>
(in fact, the contrary, using declare is unsafe in its spirit)
<lukego>
ok that's on me then. but that's always been my development philosophy. cheat as much as possible to get the program to the point where it is worth porting, rather than get distracted with portability and risk that the program doesn't get finished at all
<lukego>
easier to port a working non-portable program than to finish an incomplete portable program.
<jackdaniel>
I'm not convinced that this is a proper justification of sloppy declarations, but it is your program so there is no need for me to be convinced ,)
<splittist>
Why is CHECK-TYPE annoying?
<lukego>
Just seems like it will lead to more clutter to me. I'm already putting effort into untangling my test cases from my application logic so that I can look at each one in peace from the other
drbluefall has quit [Ping timeout: 264 seconds]
GZJ0X_ has quit [Remote host closed the connection]
<jackdaniel>
why can't you validate directly in the constructor?
<lukego>
I guess that's hard to answer since it depends on how initialization is done and how much depends on the context of the callre
<shka_>
check-type is the right thing to use for the type checking in CL
<shka_>
sometimes you ought to use declare, but it is mostly for performance
<lukego>
Maybe. There's also e.g. the quid-pro-quo library that provides another valid solution, which has a nice separation-of-concerns feel about it to me, but that's not in quicklisp and frankly has quite a bit of machinery in its implementation.
<shka_>
oh, yeah, quip-pro-quo is awesome
<shka_>
i highly recommend it
<lukego>
there are also around methods and before methods and after methods... so don't tell me there isn't more than one way to do it thankyouverymuch :)
<jackdaniel>
there are many ways to do that, it is just declare is not one ^_^
<shka_>
well, you can CHECK-TYPE in after method :D
<shka_>
but yes, declare is not reliable solution
<jackdaniel>
around if you are interested in the function result
<jackdaniel>
and if you want to validate argument, that would be probably a before method
<splittist>
Who knows what those crazy sbcl folks will do next?
<shka_>
jackdaniel: that's how quid-pro-quo works, actually
<shka_>
tremendously useful
<estest>
Making use of SBCL's behavior of type checking declares is a nice bonus of developing in SBCL, much like its generally fast assembly output (especially when you declare types) is a nice bonus, though if your program actually should rely on types being checked, an explicit check-type or some other mechanism is a good idea.
<lukego>
quid-pro-quo seems to be not in quicklisp, and to have dependencies that are also not in quicklisp, which is a bit of a enthusiasm damper
pegu has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
<shka_>
damn
GZJ0X_ has joined #lisp
<shka_>
it used to be in quicklip
madage has quit [Remote host closed the connection]
<pyc>
Need feedback with code style: https://plaster.tymoon.eu/view/2316 I have auto-fill-mode enabled, so as I type long strings, Emacs automatically inserts line-breaks. Is this good code formatting? I am curious about the two spaces that Emacs has inserted as prefix after each line-break.
madage has joined #lisp
<lukego>
and trying to load it is giving me a "This is probably a bug in SBCL itself" error involving metaclass compilation, which sure does play into my "gee that looks like a lot of implementation machinery" first impression
<estest>
I also find leaning on the implementation against portability to only be worth it when you need a particular feature it has for which there's not a good portability layer. Like why use sb-thread:make-thread when bordeaux-threads exists. Otherwise being portable and even testing in other implementations from time to time doesn't really slow me down, and can sometimes find tricky bugs earlier.
<lukego>
estest: yeah that sounds pragmatic.
<lukego>
Just now I'm only trying to find a sufficiently pleasant way to write testing code such that I will actually do it. The main barrier to instrumenting my code with tests is clutter and verbosity.
<lukego>
(and now also metaclass compilation bugs but I'll treat that as a dead-end...)
<lukego>
Maybe a good CL lawyer can help me find an acceptable formulation of the serapeum:-> function type declaration macro, such that function type declarations are strictly for documentation purposes, and any utility in the form of test coverage on SBCL is purely accidental
<lukego>
(and in truth I'd expect the really proper test coverage to come from approaches like beach outlined, with high-level functional testing, and what I'm trying to supplement that with now is just some scaffolding to help me get the nuts and bolts right before the structure is in place)
<shka_>
lukego: ok, so ftype declaration serve the following purpose
<shka_>
first: it allows for efficient type inference
<heisig>
lukego: For my last project, I defined my own document-[function,variable,...] macros that expand into (setf (documentation ...) ...) and some fancy extras.
<shka_>
secondly: it allows implementation to use the inferred types to warn when you are using aref on list ans so one
<shka_>
however, you should not count on these to give you runtime errors when types mismatch
<heisig>
One such extra was that it would take a list of forms and add them (and the results of evaluating them) as examples to the documentation string.
<estest>
pyc: I'd prefer the spacing to align the text with the first character of the string, i.e. the A in "Alice is.." is on the same column as the b in "been working".
<shka_>
heisig: did the same, documentation-utils-extensions
<estest>
But I'd only do that for docstrings or strings I know will be processed for display and have the newlines/lead spacing taken care of; for a raw record your example suggests you probably don't want newlines in the source string, so consider letting it be long (and word-wrapping) or concatenating broken up bits...
cage_ has joined #lisp
<shka_>
lukego: so in summary, ftype declarations are useful in a certain context, but not beyond it
cage_ has quit [Client Quit]
<pyc>
estest: thanks
<shka_>
therefore, it is worthwhile to use them, but one must be careful to not misuse
<lukego>
shka_: that sounds reasonable. but if I'm honest I'm thinking of them as assertions that can be allowed to propagate (and inhibited from doing so in performance sensitive contexts)
<shka_>
my personal rule of thumb is to use ftype declarations for internal functions, but not for the interface functions
<lukego>
I'll see how I go, probably they are not actually the right tool for the job, but ask me again in ten minutes..
<shka_>
well, they are not assertions
<shka_>
don't consider them to be any good for runtime
<shka_>
use check-type for stuff that is expected to be called by the user, you may use ftype and declare for the internal stuff (though, at least initially check-type is not a bad idea either)
zmv- is now known as notzmv
notzmv has quit [Changing host]
notzmv has joined #lisp
<shka_>
besides, sbcl can deduce returned function type even without the explicit declarations
<shka_>
if it is possible, at least
<shka_>
which often is not
<lukego>
yeah but there are types and then there are types e.g. I might want to provide a (satisfies foo) type that's stricter than what sbcl would infer.
<shka_>
anyway, i am saying this because that's what i do and it seems to work just fine
<lukego>
but maybe it's time for me to "read the room" and see that SBCL-specific hacks are not popular topics for discussion in here even in the early freewheeling days of a project that are always spent trying out and discarding bad ideas anyway
<shka_>
lukego: well, in that case you may define returned type of the function, but check-type the input types
<shka_>
overall, simply don't think about type declaration as suitable for checking the input types
<lukego>
I'm much more attracted to out-of-band top-level declarations like (-> read-floorplan (string function) valid-floorplan)) than anything that adds multiple lines to the actual function definitions
<lukego>
but maybe that will pass, I have been too busy fighting with you guys to actually try it yet :)
<lukego>
that's an extreme position since I'm using SBCL and SBCL says that it treats types as assertions and guarantees that they will be tested under specific conditions that I can ensure
<shka_>
well, as i said, it is FINE for internal functions that are not exposed, it is NOT FINE for external functions
<shka_>
anyway, that's all i had to say
<splittist>
Having just reviewed a project of mine with function names like FROB and PROCESS I will refrain from giving further programming advice (:
<lukego>
One happy thought is that with any kind of test instrumentation in my application code - whether with CHECK-TYPE, or FTYPE, or QUID-PRO-QUO - I can probably throw away these boring unit tests that I've been writing. The main purpose of those is just to keep silly errors from propagating e.g. a function returning the wrong object and finding out later when it's hard to track down what happened.
<lukego>
splittist: :)
<lukego>
The situation I want to avoid is "oh, whoops, that innocent refactoring I did in PREINIT-FROB forgot to set the FIZZ slot, and that's why I have these twenty *sldb* buffers popping up all over the place
<lukego>
I should have known that if I found myself writing unit tests I was probably doing something wrong...
<lukego>
thanks for the vigorous exchange of ideas :) now, kids to collect...
<jackdaniel>
sounds like a plan. /me starts writing a noise generator
<marcoxa>
jackdaniel the OOK compiler is at your service :)
supercoven has joined #lisp
<jackdaniel>
Ook!
toorevitimirp has quit [Remote host closed the connection]
<pyc>
marcoxa: do you know why Emacs decides to insert two spaces to indent all the continuation lines of my long string in the example I shared earlier: https://plaster.tymoon.eu/view/2316#2316
<beach>
pyc: Emacs is not great when it comes to indenting Common Lisp code, but it's the best we have.
wxie has quit [Ping timeout: 256 seconds]
toorevitimirp has joined #lisp
Sheilong has joined #lisp
<pyc>
beach: thanks for the explanation
<beach>
Sorry to have to give you the bad news.
<andreyorst>
beach: I've thought that Emacs when used with SLIME or SLY gets some info from runtime to indent code more or less correctly?
<andreyorst>
and some hueristics like analyzing macros to contain argument named body
<beach>
andreyorst: Yes, but it is fundamentally broken, because of the way it decides what is code and what isn't.
<andreyorst>
can you share some examples?
Bike has joined #lisp
<andreyorst>
I've never had too much trouble, though I don't write too much common lisp atm
<beach>
andreyorst: Try the following experiment: In a buffer in Lisp mode type (let ((aaaaaaa<RETURN> and observe the indentation of the next line
<beach>
andreyorst: Now type instead (let ((prog1<RETURN> and observe again.
dbotton has joined #lisp
<beach>
Emacs incorrectly decides that the PROG1 in the second example is an operator.
<beach>
So it has not analyzed the text enough to know that we are dealing with a LET binding.
<beach>
That's just one example.
<andreyorst>
with let I don't see any problems, it aligns the indentation to last opened parenthesis
<Nilby>
The depth of my disgruntlement with Emacs is nearly unfathomable. But it's STILL the least sub-optimal.
<andreyorst>
the prog1 is weird indeed
<beach>
andreyorst: Not weird. It just takes (PROG1 to be the beginning of a special form.
<andreyorst>
yes, I understand, I just thought that it does a bit more analysis, and will think that prog1 is a binding, not a call, that's what kinda weird
<andreyorst>
seems like hardcoded indentation rule
<beach>
What is weird is that the broken technique it uses kind of works in so many cases.
<splittist>
Hasn't lukego finished swank-lsp yet?
<splittist>
(Just to be clear - I just made that up.)
nicktick has joined #lisp
toorevitimirp has quit [Ping timeout: 260 seconds]
<Nilby>
I've recently been trying out the "pretty printer" to format code, but as you may know, without some undiscovered tweaking, it mangles it.
tfb has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
cchristiansen has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
<Nilby>
One of my faviorite semi-ironic quote from the spec is: "the necessary flexibility is provided for individual programs to achieve an arbitrary degree of aesthetic control."
jprajzne has joined #lisp
skapata has joined #lisp
<Xach>
Nilby: the pretty-printer seems to be underused to me. i would like more reading material on its use, including working examples from the past of neat uses.
fitzsim has joined #lisp
kevingal_ has quit [Ping timeout: 272 seconds]
kevingal has quit [Ping timeout: 272 seconds]
<Nilby>
Xach: Me too! I've read the XP paper, but it tends to put me to sleep.
random-nick has joined #lisp
<jackdaniel>
I've been tracking the most mysterious bug ever a moment ago
<jackdaniel>
it was that the first definition was always ignored (of one particular macro)
<jackdaniel>
after investigating, and confiring with a second and a third implementation I was amused - the form was not expanded
<jackdaniel>
despite the macro being defined a few lines before
<jackdaniel>
after throughful investigation, and narrowing the test case to 10 lines of the code I've found it! a stray backquote at the end of the macro that looked exactly like 100 other pieces of dust on my monitor
<jackdaniel>
I'm going to cry in the kitchen :)
kevingal has joined #lisp
<jackdaniel>
(emacs colored this stray backquote in bronze and that matches the color of dust when highlighted by sun here, and makes it very blendable into the background)
<Nilby>
jackdaniel: lol, I've had the same thing happen, with a comma vs a dot and piece of dust in just the right place.
gitgood has quit [Ping timeout: 264 seconds]
surabax has joined #lisp
<Nilby>
Now I have a weird habbit of cleaning my screen when I'm tired and I get a macro bug.
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
jeosol has quit [Quit: Connection closed]
<Nilby>
Maybe someone should invent a macro highlighting mode that enlarges punctuation.
<Nilby>
or like turns all commas red
GZJ0X_ has quit [Remote host closed the connection]
<_death>
just avoid commas, backquotes, quotes, dots..
GZJ0X_ has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
<Nilby>
_death: are you suggesting we actually (quasi-unquote ...) and such?
GZJ0X_ has quit [Remote host closed the connection]
<jackdaniel>
I think that it was a joke
GZJ0X_ has joined #lisp
<Nilby>
`(,@(got me))
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
GZJ0X_ has quit [Remote host closed the connection]
aartaka has joined #lisp
epony has quit [Quit: upgrades]
gitgood has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<_death>
there was an old (Lisp Pointers?) article on pretty printing Lisp to a Pascal-like.. there's also http://norvig.com/ltd/doc/tool.html#inside2 which I've not yet looked into much
dbotton has joined #lisp
dbotton has quit [Client Quit]
<_death>
and SBCL has pretty printer rules for CL operators, though sometimes in the cryptic format notation :/
caret has joined #lisp
<Nilby>
That Dylan pretty printer is quite an interesting example.
<Nilby>
heh, I probably dodn't need to know more test frameworks, but RT is actually still used in places
<_death>
I wonder why no one writes an actual regression tester that stores the results the first time (or when told to) and compares to the new results.. I wrote something like that to test my solutions to puzzles like advent of code and rosalind (though I didn't store the results automatically).. then it can be extended to also test performance regressions
<Nilby>
I suppose for many things the results are t/nil, but beach was talking earlier about his markov chain fuzzer style testing.
<Nilby>
I think result saving is a good idea though.
caret_ has joined #lisp
caret has quit [Disconnected by services]
caret_ is now known as caret
<beach>
Nilby: No, nothing fuzzy. It is just that I need for the same kind of operation to be repeated with some significant probability, like INSERT for instance. Otherwise, the Flexichain will forever remain short and the resizing operations won't be sufficiently tested.
<_death>
you can also keep the seed.. I can imagine a counterargument about sampling the problem state anew each time, but then maybe that means your samples are too small/uniform
<Nilby>
Hmmm. I guess randomized valid input isn't exactly the same as fuzzing with random invalid input.
<beach>
Right, not exactly the same.
<_death>
it's just for compression
<Nilby>
It's like those joke random sentence generators running the parser backwards, but with AMB or something.
<_death>
that MERL site also has some Waters publications about stochastic grammars ;)
kevingal has quit [Ping timeout: 272 seconds]
waleee-cl has joined #lisp
<Nilby>
Nice find. There's some fascinating papers in there. (e.g. KBEmacs)
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
drl has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
Alfr_ has joined #lisp
jonatack has joined #lisp
Alfr has quit [Ping timeout: 258 seconds]
nij has joined #lisp
<nij>
Suppose I have a list of READable stuff. Is there a package that helps me edit this list by editting its content through an emacs buffer?
pfdietz has joined #lisp
<beach>
What's wrong with PRINT followed by editing, followed by READ.
<nij>
beach: what do you mean by editing?
<beach>
I assumed you meant what you normally do in an Emacs buffer, like inserting and deleting characters.
<nij>
yep
<beach>
... or words, or expressions.
<nij>
yep
perrier-jouet has joined #lisp
<nij>
Editting the list (setf lst '(1 2 3)) by editting the buffer that contains "1\n2\n3".
<nij>
You can use your favorite keybindings to make change to that buffer
<nij>
and press a key to update the list
<lukego>
_death: I've written a performance regression tester a bit like that. spends hours running permutations of configurations and workloads on a system, collects all the data in a big CSV, allows you to do e.g. ANOVA to compare different software versions and say "hmm config option FOO is really slowing down workload BAR in the new release"
<lukego>
even hooked it into a CI that would automatically detect performance regressions. that was fun.
charles` has joined #lisp
Cthulhux` has joined #lisp
Cthulhux` has quit [Changing host]
<_death>
lukego: very cool.. I remember a post from a year ago about boinkmarks.. wonder what sbcl uses nowadays
<lukego>
beach: Hey, humble idea to borrow a leaf from your testing book, I realize that when I'm converting data from text to objects then an easy way to get testability might be just having a canonical print routine to turn it back to test. then I can e.g. (assert (string= (tostring x) (tostring (fromstring (tostring x)))) to differentially test the printer and reader against each other
kevingal has joined #lisp
<lukego>
so for example if I goofed and put a value in the wrong slot it'd be caught automatically, without me having to manually create examples with tests that know exactly how the object representation should look
kevingal_ has joined #lisp
pagnol has quit [Ping timeout: 240 seconds]
<beach>
lukego: Sounds good.
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
save-lisp-or-die has joined #lisp
<Nilby>
nij: there's slime-edit-value
kam1 has quit [Ping timeout: 265 seconds]
jonatack has quit [Ping timeout: 264 seconds]
notzmv has quit [Ping timeout: 240 seconds]
hiroaki_ has quit [Ping timeout: 272 seconds]
zupss has joined #lisp
warweasle has joined #lisp
Cymew has quit [Ping timeout: 272 seconds]
tempuser43 has joined #lisp
tempuser43 has quit [Remote host closed the connection]
hiroaki_ has joined #lisp
zmv has joined #lisp
zmv is now known as Guest56442
<nij>
Nilby: Gasp! Indeed :-O
rgherdt has joined #lisp
<nij>
Now the only problem is to lispily format a long list such that the length of each row isn't more than, say, 80.
<Demosthenex>
hrm. anyone using clods-export? can't get text rotation to work.
charles` has quit [Ping timeout: 264 seconds]
long4mud has quit [Quit: WeeChat 3.0.1]
jeosol has joined #lisp
luni has quit [Quit: Connection closed]
dbotton has joined #lisp
<jmercouris>
if we have (reduce #'str:concat (loop for i from 0 to 10 collect "salmon"))
<jmercouris>
is there a better way?
<jmercouris>
instead of reducing, can I "accumulate" a string or something?
<jmercouris>
I could use a "with" and concatenate to it, I guess
<jmercouris>
I'm looking for something built-into loop though
<Nilby>
I usually use with-output-to-string in a loop. You could also just output to a string with a fill-pointer.
yoseph has joined #lisp
jonatack has joined #lisp
<Nilby>
e.g. (let ((s (make-array 0 :element-type 'character :fill-pointer t))) (loop for i from 0 to 10 do (format s "salmon")) s)
cosimone has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
jonatack has quit [Client Quit]
kevingal_ has quit [Ping timeout: 272 seconds]
kevingal has quit [Ping timeout: 272 seconds]
yoseph has left #lisp [#lisp]
bilegeek has joined #lisp
charles` has joined #lisp
nij has joined #lisp
nij has left #lisp [#lisp]
varjagg has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
GZJ0X_ has joined #lisp
froggey_ is now known as froggey
charles` has quit [Ping timeout: 240 seconds]
GZJ0X_ has quit [Ping timeout: 260 seconds]
xanderle has quit [Ping timeout: 240 seconds]
long4mud has joined #lisp
<jmercouris>
Nilby: interesting solutions
<jmercouris>
thanks for sharing
<jmercouris>
I think I still prefer reduce
<jmercouris>
even if it is less efficient than others
varjagg is now known as varjag
<shka_>
jmercouris: use format
scoofy has quit [Read error: Connection reset by peer]
estest has quit [Ping timeout: 264 seconds]
<shka_>
jmercouris: (format nil "~{~a~}" (loop for i from 0 to 10 collect "salmon"))
charles` has joined #lisp
<shka_>
or, even better, what Nilby recommended
estest has joined #lisp
edgar-xyz has quit [Quit: Leaving]
<shka_>
(with-output-to-string (stream) (loop for i from 0 to 10 do (format stream "salmon")))
<shka_>
jmercouris: reduce is a really bad option here since concat will allocate new copy fo string for each element of the sequence being reduced
<jdz>
The nice thing about format is "~{~A~^, ~}".
<shka_>
also, technically speaking function passed to reduce should handle being called with 0, 1 or 2 arguments
<shka_>
and 0 is a problem
<Nilby>
The format one is slower actually than the reduce, but takes much less memory, but the with-output-to-string seems the fastest.
user51 has joined #lisp
<_death>
shka: they will never be called with one argument, and you can provide an initial value to ensure they will never be called with no arguments
user51 has left #lisp [#lisp]
<Alfr_>
... or ensure that sequence is never empty, then it won't be called with zero arguments as well.
jonatack has quit [Read error: Connection reset by peer]
<fiddlerwoaroof>
Reduce is just a loop with an accumulator, so if you control the initial value there's no reason not to mutate it :)
jonatack has joined #lisp
<fiddlerwoaroof>
If some FP purist complains, just explain that you're using dynamic linear types.
<jasom>
fiddlerwoaroof: but at that point why use reduce at all, and just put the mutation in the loop body?
<fiddlerwoaroof>
jasom: I like the structure of reduce
<fiddlerwoaroof>
for whatever reason, I prefer the way reduce reads to the alternatives
<fiddlerwoaroof>
Also, the lambda has to be (lambda (acc next) ... acc) there
wanko has joined #lisp
kaiwulf has joined #lisp
nicktick has quit [Ping timeout: 256 seconds]
nicktick has joined #lisp
luni has joined #lisp
aeth_ has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
aeth has quit [Ping timeout: 264 seconds]
aeth_ is now known as aeth
<wanko>
hello, is it okay to ask beginner scheme questions here, or is there a different channel for that?
<Bike>
this is not a scheme channel. i think you want #scheme maybe
<warweasle>
Woot! I made a macro that amortizes long calls to files.
<wanko>
Bike: thanks
Sauvin has quit [Read error: Connection reset by peer]
kevingal has joined #lisp
kevingal_ has joined #lisp
random-nick has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
kevingal has quit [Remote host closed the connection]
kevingal_ has quit [Remote host closed the connection]
jonatack has quit [Read error: Connection reset by peer]
jonatack_ has joined #lisp
jonatack_ has quit [Client Quit]
jonatack has joined #lisp
iskander has joined #lisp
drbluefall has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack_ has joined #lisp
gioyik_ has quit [Remote host closed the connection]
gioyik_ has joined #lisp
jonatack_ has quit [Read error: Connection reset by peer]
jonatack__ has joined #lisp
jonatack__ has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
domovod has quit [Ping timeout: 264 seconds]
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
<dbotton>
Is there a function that "trims" off the last character off a string?
<Inline>
yes
<Bike>
you can use subseq for that.
<dbotton>
(I know subseq but complicates what I am writing)
<Xach>
dbotton: specific characters or any character?
<dbotton>
any
<dbotton>
I know also trim
arpunk has quit [Remote host closed the connection]
<Xach>
subseq is the thing, and wrap it if the arguments aren't what you like
jonatack has quit [Read error: Connection reset by peer]
rumbler31 has quit [Remote host closed the connection]
jonatack_ has joined #lisp
<dbotton>
I assume there is no way in lisp to "use" the sequence passed to subseq as part of an expression to calculate end?
rumbler31 has joined #lisp
jonatack_ has quit [Read error: Connection reset by peer]
jonatack_ has joined #lisp
<dbotton>
(subseq s 0 (- (length s) 1))
<dbotton>
I just want to avoid needing to store s
<jasom>
dbotton: I think various utility libraries let you do python-style passing of negative values for subseq ranges. I can't speak to the quality of any of them though.
anticrisis has joined #lisp
<Xach>
dbotton: (defun trim-last-char (s) (subseq s 0 (1- (length s))) is what i might do if i didn't a cluttered expression
<dbotton>
Thanks
zdm has quit [Read error: Connection reset by peer]
<markasoftware>
sounds like a good time for anaphora :)
<Xach>
ptui!
ukari has quit [Remote host closed the connection]
luni has quit [Quit: Connection closed]
<alanz>
dbotton, fwiw I am playing with a toy project on top of clog. As a learning exercise
eschatologist has quit [Remote host closed the connection]
ukari has joined #lisp
loke[m] has joined #lisp
<markasoftware>
(alet (make-the-string) (subseq it 0 (1- (length it))))
* alanz
having zero web skills, its a challenge
Alfr has joined #lisp
arichiardi[m] has joined #lisp
z0d has joined #lisp
<dbotton>
alanz is worth much
<dbotton>
Nothing encourages the creative process then someone appreciating it :)
<dbotton>
More then
<alanz>
I know, which is why I am speaking up. I love seeing it come together bit by bit, and appreciate the effort you put in to making clear, understandable code
dmiles[m] has joined #lisp
infra_red[m] has joined #lisp
even4void[m] has joined #lisp
<dbotton>
Thanks :)
Alfr has quit [Client Quit]
<dbotton>
<markasoftware> what is alet
<dbotton>
(I used an flat and or or less the same code in the end)
<dbotton>
flet
charles` has quit [Ping timeout: 264 seconds]
susam has joined #lisp
<dbotton>
Alanz if you create something cool love a screen shot :)
<dbotton>
Since an admin tool, maybe consider using tutorial 22 as your base and have a nice look desktop motif
sm2n has joined #lisp
<dbotton>
Then look at clod-db-admin in the tools directory for using databases with clog
ThaEwat has joined #lisp
<alanz>
thanks, will do so. I also see myself interacting with the local file system, and showinng pictures. So the desktop one is definitely a good basis
theothornhill[m] has joined #lisp
cloudy[m] has joined #lisp
sepanko_ has joined #lisp
<alanz>
its going to be slow though, this is a back-burner project for me, which I am using to learn cl at the same time (from some experience with elisp)
_whitelogger has joined #lisp
etimmons has joined #lisp
<dbotton>
Still hope someone with better language skills takes me up on project :) but if not I will do
dra has quit [Remote host closed the connection]
katco has joined #lisp
orivej has joined #lisp
dbotton has quit [Quit: Leaving]
shinohai_ is now known as shinohai
<alanz>
you are doing fine, as far as I can see. Being active and enthusiastic is the most important thing, I reckon
jonatack__ has joined #lisp
semz has joined #lisp
kam1 has joined #lisp
shka_ has quit [Ping timeout: 272 seconds]
Alfr has joined #lisp
egp_ has quit [Quit: EXIT]
egp_ has joined #lisp
cosimone has quit [Quit: cosimone]
cosimone has joined #lisp
heisig has quit [Quit: Leaving]
cosimone has quit [Remote host closed the connection]
jonatack__ has quit [Quit: jonatack__]
narimiran has quit [Ping timeout: 256 seconds]
karlosz has quit [Quit: karlosz]
charles` has joined #lisp
vutral_ has joined #lisp
earenndil is now known as moon-child
aeth has quit [Ping timeout: 256 seconds]
aeth has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
skapata has quit [Remote host closed the connection]
contrapunctus has joined #lisp
karlosz has joined #lisp
catt has quit [Ping timeout: 256 seconds]
hiroaki__ has joined #lisp
akoana has joined #lisp
hiroaki_ has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<logand``>
lukego: another option (eval `(= ,@(mapcar #'length strings)))
<logand``>
or this (funcall (compile nil `(lambda () (= ,@(mapcar #'length strings)))))
<logand``>
the options seem endless
galex-713 has quit [Ping timeout: 260 seconds]
edgar-rft has quit [Ping timeout: 246 seconds]
rumbler31 has quit [Remote host closed the connection]
<Alfr>
Be weary of call-arguments-limit.
rumbler31 has joined #lisp
pve has quit [Quit: leaving]
galex-713 has joined #lisp
surabax has quit [Quit: Leaving]
warweasle has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]