phf: use Foo;

phf: package Foo is new ffa(Width => 64*5,

phf: asciilifeform: if i have procedure foo(x in; y out), and i'm calling it with foo(a, a); is it up to procedure to ensure that y is not clobbered before x is used, or is it more that you don't call with a same variable in in and out?

phf: ( leaving this here for myself, awk's pattern for filtering uniques is !foo[$col]++ )

phf: asciilifeform: i actually tried replacing my asdf with asdf1 and the failure is that of thousand cuts. small, completely inconsequential additions to asdf file or some pointless uiop:foo-bar somewhere deep in code. some asdf files have hardcoded #-asdf3(error "asdf3 required") but then still work, etc.

phf: mode ##lmi +b foo@bar

phf: ben_vulpes: it's a silly convention, because count(anything) would've returned the row count. select count(42) from foo would've returned the same result

phf: patch/diff lets you have a patch with --- foo +++ bar in which case it seems to ~check if foo exists, then try and press against foo, otherwise press against bar~

phf: -p1 means a/foo/bar gets pressed as foo/bar

phf: yes, but you never do, also it's (run "foo" nil) or if you insist (run "foo" ()) though that last one looks funny

phf: ben_vulpes: i think best way to answer that question is to read a lot of existing code from different backgrounds (pre-2000s code, famous people code, etc.). my rule of thumb is that you use optional if ~at call site~ it's still obvious what the argument means. otherwise you promote it to keywoard. (run "foo" `("-p" "bar")) makes sense, but (run "foo" `("-p" "bar") stream) you start guessing. is it input stream? is it output stream?

phf: (curl 'http://wotpaste.cascadianhacker.com/pastes/PfVG0/?raw=true'; curl 'http://wotpaste.cascadianhacker.com/pastes/1Pq8P/?raw=true')|base64 -D -o foo.svg

phf: literally nobody can tell me what the potential downsides of `for i in xrange(1000000): a += "foo"` are

phf: ben_vulpes: i don't know how to solve that problem, but "i know, sexp will help us!" is not. you basically need to redesign a bunch of things about reader, have a custom save format (that will look closer to (DEFUN FOO () (IF BAR QUX (PROGN ...)))). sexp nature will help you ~a bit~, but like mp said it's closer to "let's save AST", because sexp don't preserve nearly enough required info ☟︎

phf: http://btcbase.org/log/2016-12-07#1578953 << just fyi, while you can diff an intermediate ~state~ of an image as a sexp, common lisp's input is a ~character stream~. builtin dispatch ~mostly~ operates on forms (like #p #. (concatenate 'string "foo" "bar")), but not always, like #\; comment reads till end of line. ☝︎☟︎

phf: cat ought to be 8-bit clean, i suspect most of the bloat will come from gnu attempting all kinds of optimization. it probably optionally mmaps cat foo, etc.

phf: trinque: how's the interface supposed to look? /log-first-message?nick=foo and it gives you html rendering? or text/plain in kako format? or?

phf: !~later tell gabriel_laddel have you considered putting ~everything~ masamune into a single tree, prepatched, so that instead of "load X, then load my patch-foo-for-X" you just have everything under single hierarchy exactly the way you expect it to run in production?

phf: http://btcbase.org/log/2016-10-03#1551486 << was it interlisp or maclisp that let you close multiple parenthesis with a single final one, like (do ((foo 1) (bar 2)) (blah (foo) == (do ((foo 1) (bar 2)) (blah (foo))) ☝︎

phf: well, if Framedragger is still parsing the znc logs, then znc does it for you. it'll be <foo> blah, or * foo blah or somesuch

phf: !~bash foo

phf: kind of tricky to cache search, since it's very one off. most load on server comes from searching (i mean it's miniscule still, but...), but i looked at analytics and search queries are all over the place. you have n hits from mentions, which ~might~ be worthwhile to cache. (like ascii does !#s foo, and then there's a dozen of hits from random ips and browsers)

phf: so the vpatch becomes something like "getting baz to work^L(load "foo") (load "bar") diff ... foo.lisp ... +... -... etc diff bar.lisp ... +... -..."

phf: you know dos "com", which was just a flat sequence of bytecodes and when you did foo.com it would just start executing foo.com with the first byte

phf: mircea_popescu: problem is that when you do a execution like ./foo on unix, ~unix~ expects "foo" to contain certain bits and do certain kind of work to appease unix upfront. that work is specific not to "x86" but to "linux v 1.1.2, compiled on full moon, by three blind monks"

phf: c-machine assembly level has a certain shape to it. when you write int foo { bar(); } an assembly of a certain pattern gets spit out

phf: $s from:blah foo

phf: $s foo ☟︎

phf: %s foo

phf: but if i just post comment with <code> foo</code> that doesn't work