EvW has quit [Read error: Connection reset by peer]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
jprajzne has joined #lisp
Patzy_ has quit [Ping timeout: 272 seconds]
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
_whitelogger has joined #lisp
hasegawatan has joined #lisp
Patzy_ has joined #lisp
jprajzne has quit [Quit: jprajzne]
hasegawatan has quit [Quit: WeeChat 2.3]
slyrus has quit [Read error: Connection reset by peer]
ex_nihilo has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
jprajzne has joined #lisp
toorevitimirp has joined #lisp
jesse1010 has quit [Ping timeout: 240 seconds]
<dbotton_>
is there a way to set a type for a constant?
<no-defun-allowed>
Inferring the type of a constant is trivial (always (EQL <value>)), but would (declare (<type> <name>)) work?
<no-defun-allowed>
declaim, not declare.
<dbotton_>
I'll look up :)
<dbotton_>
declare I know works on parameters of a function
Oladon has joined #lisp
edgar-rft has joined #lisp
arpunk has quit [Ping timeout: 258 seconds]
<dbotton_>
no sure that worked
<dbotton_>
I did (declaim (fixnum me2)) on a constant string me2 and no error
<dbotton_>
and could still use me2 as a string
arpunk has joined #lisp
<dbotton_>
so not sure how that will set up a compile time check that the constant is a string
<dbotton_>
for example
<dbotton_>
perhaps in most cases this is not needed since the constant already exists when compiling code
<dbotton_>
so type inferred
<dbotton_>
but still curious if possible
<dbotton_>
and to insure human changes keep the type I want
cosimone has quit [Quit: Quit.]
drl has quit [Remote host closed the connection]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
Oddity has joined #lisp
<beach>
Good morning everyone!
Alfr has joined #lisp
Alfr_ has quit [Ping timeout: 260 seconds]
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life has joined #lisp
Stanley00 has joined #lisp
<aaaaaa>
beach: oh, here are you again
<aaaaaa>
beach: good morning, indeed
<beach>
aaaaaa: I am here every morning.
<aaaaaa>
beach: yes. and sometimes I reply
<beach>
Right.
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
entel has quit [*.net *.split]
thonkpod has quit [*.net *.split]
cognemo has quit [*.net *.split]
boeg has quit [*.net *.split]
C-16 has quit [*.net *.split]
oldtopman has quit [*.net *.split]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
Nilby has joined #lisp
Oladon has quit [Quit: Leaving.]
<dbotton_>
<no-defun-allowed> declaim though does work on variables
yonkunas has quit [Quit: Connection closed for inactivity]
thonkpod has joined #lisp
cognemo has joined #lisp
boeg has joined #lisp
C-16 has joined #lisp
oldtopman has joined #lisp
entel has joined #lisp
<dbotton_>
does the compiler also assert during runtime or just at compile time using that?
<Bike>
in the standard, the consequences of a declaration being incorrect are undefined. some implementations define it to be a runtime error or compile time warning.
<Bike>
the standard does not mandate any compile time type operations of any kind. an implementation that ignores all type declarations is conformant.
aaaaaa has quit [Quit: leaving]
<Bike>
you can, however, get arbitrary code executed at compile time, so if you really want lisp to be ada you could maybe work something out.
<Bike>
for example, you could write (eval-when (:compile-toplevel) (unless (typep me2 'string) (error 'type-error ...)))
<Bike>
with a macro, probably
<beach>
It seems to be common for people coming from statically typed languages to over-emphasize type checks and type declarations in Common Lisp.
<dbotton_>
ok I certainly could add the run time checks in a macro but compile time seems need to embellish the implementation itself
<dbotton_>
beach I see the advantage of not being to particular but for certain types of apps everything helps
<Bike>
this would be a compile time check.
<beach>
I forget who pointed this out, some talk I found online no doubt, statically typed languages often force the programmer to supply information that is typically not correct way too early in the development process.
<Bike>
see the (:compile-toplevel)? that means that code runs while compile-file is running.
<dbotton_>
so every use of the variable anywhere will get the check with that?
<Bike>
no.
<Bike>
i don't understand what that means. if it's a compile time check, what would it mean to check it at every use? do you want a runtime check whenever it's used?
<dbotton_>
that is what I mean by need to embellish the implementation
<dbotton_>
no want to insure every use of that variable is checked
<Bike>
at runtime??
<Bike>
if you want it to check at runtime please say so.
<dbotton_>
for example at compile time
jprajzne has quit [Quit: jprajzne]
<Bike>
but what does it mean to check a USE at compile time
<beach>
It is silly to want a run-time check whenever a variable is used. Take the function IDENTITY, why would a call to it require the type of the argument to be checked?
<Bike>
i mean, it's a constant. you define it once. it does not change.
<Bike>
it only has one value in the compiler.
<dbotton_>
so say (setq x 123) when x typed as a string
<Bike>
you said it's a constant!
<dbotton_>
ah I was talking originally about that
<dbotton_>
sorry
<dbotton_>
I mentioned after that declaim worked on variables
<Bike>
ok, whatever. so if you want all uses of a variable checked you could put in a runtime check and make it transparent with a symbol macro.
<dbotton_>
at least in sbcl
davepdotorg has joined #lisp
<Bike>
then if your implementation does type inference, it can eliminate the test code when it can prove the type is always correct
<dbotton_>
the be idea is to avoid user error
<Bike>
and if it can prove it's always wrong, it can signal a warning
<Bike>
pretty sure that would work in sbcl.
<Bike>
you'd also get the same effect with a declaration, but again, the standard does not guarantee declarations are used in any way.
<Bike>
(type declarations, anyway)
mindCrime_ has quit [Ping timeout: 240 seconds]
<iissaacc>
beach: re your admonishment last night i looked at some of your code on github and I now agree that writing the package prefix is the way to go, haha. No need to switch around files looking for symbols
<dbotton_>
if it can prove cant be used beyond the type constraints that would be cool to optimize out a check
gravicappa has joined #lisp
jprajzne has joined #lisp
<dbotton_>
but I guess need to see if sbcl adds based on the declaim to start with the runtime check
<dbotton_>
been writing a tutorial as I learn for programmers of imperative algol like languages:)
<dbotton_>
none of the books or tutorials I found would appeal or work well with most programmers I hire
aartaka has quit [Read error: Connection reset by peer]
<ludston>
note: ideomatic cl is imperative
<dbotton_>
but tuts seem to focus on every thing else
<dbotton_>
mine starts with packages then functions then vars
<dbotton_>
the way they think
<dbotton_>
decompose top down
<beach>
iissaacc: Great!
<Alfr>
dbotton_, not sure that will end well, w/o introducing symbols, the reader, quote and lists first, your readers will have a hard time following any examples and keep guessing about what actually will get evaluated. (I'm omitting reader macros, yes.)
<dbotton_>
it gets slipped in so far :)
<Alfr>
I at least think that you'll need the above to explain packages, functions etc.
<dbotton_>
ill share once further
<dbotton_>
but I think will work if not oh well I learned lisp at least
<beach>
dbotton_pc: A closing parenthesis is never preceded by whitespace.
<dbotton_pc>
thanks!
<beach>
[and an opening parenthesis is never followed by witespace]
<beach>
... including newline.
<no-defun-allowed>
Parens are more like function calls than curly braces in curly brace languages.
<beach>
load("hello3.lisp") is wrong.
wglb has joined #lisp
<beach>
I would definitely remove the (declare (fixnum x))
sts-q has joined #lisp
<no-defun-allowed>
Most Lisp code doesn't have a main entry point; but everything is run when you load a file, though DEFUN obviously delays evaluation until the function that is being defined is called.
sts-q has quit [Client Quit]
<beach>
And I would definitely remove the (declaim (fixnum *x*))
<dbotton_pc>
beach why?
<beach>
dbotton_pc: FIXNUM is a highly implementation-specific declaration, and there is no reason to believe it is true.
<beach>
dbotton_pc: Again, a declaration is a promise by the programmer to the compiler. It is best not to make such promises if you are not sure they can be kept.
<dbotton_pc>
no-defun-allowed the idea is to make it easier for them to "picture" the ()s as something familiar
sts-q has joined #lisp
<no-defun-allowed>
You should picture (f x1 ... xn) as f(x1, ..., xn) then.
<dbotton_pc>
though I got that but ill reread and make sure there
ggole has joined #lisp
<dbotton_pc>
beach sbcl uses those for its compiler checks
<beach>
dbotton_pc: You should make sure that (setf x (+ x delta)) is an approximation of the meaning of (incf x delta), because you can't just substitute any place for x and have it work.
<dbotton_pc>
is there another way?
<no-defun-allowed>
{ s₁; ...; sₙ } would usually be written (progn s₁ ... sₙ)
<beach>
dbotton_pc: I am talking about the standard. You should be teaching the language and not SBCL.
<no-defun-allowed>
If you must check, you should pick a type that isn't tied to the implementation, like INTEGER.
<beach>
dbotton_pc: But, more importantly, there is absolutely no reason to declare if FIXNUM.
<dbotton_pc>
I likely would still keep and indicate that
<dbotton_pc>
ok
<no-defun-allowed>
Even on SBCL, the value of (expt 2 32) may not be a FIXNUM on some machines.
<beach>
no-defun-allowed is right, INTEGER is better, but still not a good way to teach Common Lisp.
<dbotton_pc>
i'll try and choose a better type
<beach>
dbotton_pc: You need to indicate the same approximation for PUSH and POP. Basically every time the explanation contains the variable more than once.
<dbotton_pc>
I want to still indicate the compiler is as smart to static check if desired
<beach>
dbotton_pc: That is definitely the wrong way to start learning Common Lisp.
<dbotton_pc>
ok
<dbotton_pc>
when I get further down to those operators i'll run it by again
<dbotton_pc>
those were some tables i got from a tut on line and copied for now
<no-defun-allowed>
Also, for reference, generics can be achieved using static typing, but usually programmers that use static typing use the word "generics", so you may know that already.
<beach>
I am sorry to hear that. Especially if it did not mention that they are approximations.
<no-defun-allowed>
(It would be polite to record and cite what reference materials you copy as well.)
<dbotton_pc>
beach, we will see
<dbotton_pc>
if wrong way in the end :)
<beach>
You are free to do what you want, of course, but since you asked for remarks...
<dbotton_pc>
I will likely change much but I think need to speak Algol not lisp to Algol brains
<no-defun-allowed>
I think you should try not to mess up if you're writing a book aimed at people who aren't as experienced with Lisp.
<dbotton_pc>
no-defun-allowed if I keep for sure
<dbotton_pc>
will atribute
<dbotton_pc>
well is my notes to teach my self first and one I actually know lisp if still think worthwhile (and others) figure worth sharing wider
<beach>
dbotton_pc: Your grammar is strange. It is hard to parse what you write here.
<dbotton_pc>
sometimes I am sure, it is more notes, need to rewrite if do more with it for sure
<no-defun-allowed>
From observation, people get excited and either write questionable Lisp implementations or books early on. I did the former several years ago, and I think you should thoroughly shake out the Algol programmer in your head (and eventually in your readers' heads) before embarking on either.
<aeth>
dbotton_pc: Imo, if you want to translate C-style numerical types into CL, think in terms of (unsigned-byte foo) or (signed-byte foo) which are a more verbose equivalent to intfoo_t or uintfoo_t, rather than fixnum. Of course, they might be bignums or fixnums depending on specifics.
<beach>
dbotton_pc: Like, I would have written "I need to rewrite it if I do more with it, for sure", rather than "need to rewrite if do more with it for sure"
<dbotton_pc>
I use websockets to make the browser a dumb terminal
<dbotton_pc>
send across javascript but all login on server side
<iissaacc>
beach: yeah? I'm your man for anything linguistics or just writing related
<iissaacc>
keen to contribute to things so I can soak up more lisp knowledge
<iissaacc>
(and so I can brag on my CV...)
jprajzne has quit [Quit: jprajzne]
treflip has joined #lisp
<dbotton_pc>
have to get some sleep, thank you all
dbotton_pc has quit [Remote host closed the connection]
skapata has quit [Remote host closed the connection]
jprajzne has joined #lisp
<beach>
iissaacc: I was thinking about the significant task (that I often take on) to check the (Common Lisp related) writing of non-native speakers of English.
<beach>
iissaacc: Depending on the native language of the writer, the problems are always the same, so it can get a bit boring sometimes.
<beach>
Even for native speakers, an omitted comma can change the meaning of the sentence, and stuff like that is hard to spot by the author.
blackadder has joined #lisp
blackadder has quit [Changing host]
blackadder has joined #lisp
<iissaacc>
Indeed, and L2 speakers often use syntax that sounds strange for a native speaker and can impede understanding of content that needs to be precisely expressed
<beach>
Exactly!
<iissaacc>
Plus I find it helps me think about the topic from different angles when I discuss it with a reviewer
<beach>
You mean when you are the author?
<iissaacc>
yes
<iissaacc>
My MA supervisor is not a native English speaker, so I had to be more careful with my verbal explanations and that often helped me find holes in my ideas
<beach>
Interesting.
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
galex-713 has quit [Ping timeout: 256 seconds]
galex-713 has joined #lisp
<ludston>
Consider: using slang and colloquial language can be a substitute for good grammar, excluding esl.
davepdotorg has joined #lisp
<no-defun-allowed>
That would be very unfortunate for non-native readers and translators.
davepdotorg has quit [Ping timeout: 246 seconds]
<edgar-rft>
Let's translate all documents with Google Translator to make sure that nobody understands anything anymore.
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
jprajzne has quit [Quit: jprajzne]
iissaacc has quit [Ping timeout: 258 seconds]
<Alfr>
Make it a round trip, call it normalization, and then shred the originals.
<no-defun-allowed>
I am waiting eagerly for someone to pass the Common Lisp Hyperspec through Google Translate at least 20 times.
ebrasca has joined #lisp
hiroaki has quit [Ping timeout: 272 seconds]
<Blukunfando>
Don’t forget to add a common lithp to the Hyperthpec in the firtht plathe.
<no-defun-allowed>
Hopefully there are fewer of those people then.
<Blukunfando>
Yeah, most of them probably pride themselves on not wanting anything to do with Lisp.
<iissaacc>
ludston: it depends on what you mean by slang. I've seen this opinion expressed by Americans who then pepper their writing with Americanisms which they obviously don't consider "slang"...
davepdotorg has joined #lisp
bocaneri has joined #lisp
pve has joined #lisp
<ludston>
What I'm saying is that you can have low-status effective communication through slang, vs high status effective communication through "good english". I think it is interesting because it isn't necessarily an intuitive idea, and it's useful to try both these modes of communication when you are teaching.
whiteline has joined #lisp
<no-defun-allowed>
Blukunfando: Well, now that you mention it...you're not wrong.
<jackdaniel>
I think taht this discussion went beyond common lisp topic
blackadder has quit [Quit: Leaving]
<jackdaniel>
there is a more universal channel #lispcafe for interesting discussions like this
<iissaacc>
ludston: ah yeah we're on the same page then
<iissaacc>
*joins #lispcafe*
ldb has joined #lisp
<ldb>
good afternoon
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
bocaneri is now known as Sauvin
scymtym has joined #lisp
Bourne has quit [Ping timeout: 265 seconds]
<beach>
Hello ldb.
<ludston>
jackdaniel: it's somewhat off-topic. In a strange way a macro is a bit like slang, isn't it? i.e. Domain specific, and optimised for ease of use
<jackdaniel>
each newly introduced operator is a "slang verb", macros have irregular argument evaluation rules
jprajzne has joined #lisp
<_death>
slang may help both lispers and nonlispers understand, e.g. I'm cdring down the street in a car
<contrapunctus>
lol
<aeth>
what is rplacd if not slang?
<beach>
Not at all. It is part of the defined vocabulary of Common Lisp. Kind of like the equivalent of the contents of the "dictionnaire de l'académie française".
mmohammadi9812 has joined #lisp
<ludston>
I'm not sure I agree, because most operators, i.e. named functions are isomorphs of real life/English problems modelled with existing comp-sci concepts and are as such not extending the vocab of lisp as much as just being an expression of an existing language.
Nilby has quit [Ping timeout: 240 seconds]
<loke>
If you use the term "rplacd" when discussing C++, I'll be perfectly happy accepting that as slang.
<loke>
But in the context of Lisp it has a very precise meaning.
<ludston>
the more I think about it, the less anagolous it feels, but we do avoid writing macros for pretty much the same reasons we avoid using slang: the outgroup has to jump a learning wall
dbotton has joined #lisp
dbotton_ has quit [Read error: Connection reset by peer]
<ck_>
I didn't know we were avoiding macros :o
<no-defun-allowed>
Would I prefer for the outgroup to read the crap my macros expand to then?
<ldb>
After trying to migrating 2k lines of a OCaml syntax tree walker I think macro is a precious feature
<ludston>
ck_: The rule is, prefer defun to defmacro, except when defmacro is better. Rephrased is "avoid defmacro"
<_death>
much of the jargon file is still relevant..
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
<no-defun-allowed>
The "rule" is nonsensical for things you can't do without DEFMACRO, like generating parsers, and unpleasant for something like INVOKE-WITH-RESOURCE instead of WITH-RESOURCE.
<ludston>
no-defun-allowed: only if you didn't read the second half of the rule
<no-defun-allowed>
It's a bit like saying "I after E except before C and except for <all the words that have E after I>".
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
frgo_ has quit [Remote host closed the connection]
davepdotorg has joined #lisp
<ldb>
it's just a over simplification to staging limitation
X-Scale has joined #lisp
<ludston>
no-defun-allowed: I will also accept, "It's tautological". But it's the kind of heuristic you find on corporate style-guides, learned through pain.
davepdotorg has quit [Ping timeout: 258 seconds]
hendursa1 has joined #lisp
shka_ has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
ludston: My apologies, I only come up with long formal words unintentionally.
White_Flame has quit [Ping timeout: 265 seconds]
jonatack has quit [Ping timeout: 240 seconds]
White_Flame has joined #lisp
davepdotorg has joined #lisp
orivej has joined #lisp
<aeth>
Tell people not to use macros. If there's a problem that can only elegantly be solved via macros, then they'll use them anyway. It should be a guideline, not a rule.
davepdotorg has quit [Quit: Leaving...]
ljavorsk__ has joined #lisp
<jackdaniel>
PG had a compelling argument against this line of thinking. Even when you have bunch of functions you still need to "learn" what they do, well written macros actually reduce amount of things to learn
<jackdaniel>
i.e (with-foo …) is much easier to use than remembering, that after calling init-foo, you need to wrap the body in unwind protect and call destroy-foo in the end
aartaka_d has joined #lisp
<jackdaniel>
another noteworthy practice which I pick from McCLIM, is that when you write a macro accepting a body, write also a function which accepts the continuation with said body
<jackdaniel>
and make said macro expand to this function
<aeth>
Macros are only straightforward when you stick to established patterns: define-foo, with-foo, do-foo, foo-case/case-foo, etc.
ljavorsk_ has joined #lisp
<jackdaniel>
(with-foo (xxx) a b c) ; -> (flet ((gensym-cont () a b c)) (invoke-with-foo xxx #'gensym-cont))
aartaka has quit [Ping timeout: 265 seconds]
ljavorsk__ has quit [Ping timeout: 264 seconds]
<_death>
one way to write programs is to come up with an interface by thinking about functions, and then spread a thin layer of macros to make things prettier.. another way is to come up with a macro form that describes the class of problems you want to solve, and have the implementation come out of that.. both ways are useful at times
<iissaacc>
the hunchentoot source is pretty amazing
<iissaacc>
quality documentation everywhere
srhm has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 256 seconds]
frgo has quit []
jesse1010 has joined #lisp
<jackdaniel>
so-called ediware is known for its quality
aartaka has quit [Ping timeout: 256 seconds]
ldb has quit [Ping timeout: 264 seconds]
<ted_wroclaw>
Agreed Edi Weitz is a gift from heaven. His book is extremely helpful as well.
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdot_ has joined #lisp
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ldb has joined #lisp
<schweers>
His book is Common Lisp Recipies, right?
Nilby has joined #lisp
<phoe>
t
<jackdaniel>
(clr (cons a b)) ; -> .
<phoe>
wait, what is clr
aartaka has joined #lisp
<no-defun-allowed>
Contents of the Lower dot thing Register
<edgar-rft>
schweers: Common Lisp Recipies is authored by Edi Weitz if that's what you wanted to know.
PuercoPop has quit [Read error: Connection reset by peer]
<no-defun-allowed>
jackdaniel's example is wrong, actually: if b is a list, then (clr (cons a b) ⇒
<no-defun-allowed>
I may have dropped a paren. (clr (cons a b)) ⇒
aartaka has quit [Ping timeout: 264 seconds]
jonatack has quit [Ping timeout: 256 seconds]
<jackdaniel>
right, and if b is a dot, then (clr (cons a b)) ; -> a
<jackdaniel>
(that's for backward compatibility with vack lisp)
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
ebrasca has quit [Remote host closed the connection]
dbotton has quit [Quit: -a- Connection Timed Out]
dbotton has joined #lisp
starch has joined #lisp
kreyren has quit [Ping timeout: 240 seconds]
<schweers>
edgar-rft: I wanted to know which book(s) Weitz wrote, but that’s close enough) ;
mmohammadi98120 has joined #lisp
sonologico has quit [Read error: Connection reset by peer]
mmohammadi9812 has quit [Ping timeout: 264 seconds]
mmohammadi9812 has joined #lisp
ramHero has quit [Read error: Connection reset by peer]
mmohammadi98120 has quit [Ping timeout: 265 seconds]
mmohammadi98126 has joined #lisp
ted_wroclaw has joined #lisp
mmohammadi9812 has quit [Ping timeout: 272 seconds]
mmohammadi98126 has quit [Ping timeout: 260 seconds]
ted_wroclaw has quit [Client Quit]
sts-q has quit []
sts-q has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
treflip has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
treflip has joined #lisp
galex-713 has quit [Ping timeout: 240 seconds]
galex-713 has joined #lisp
zaquest has quit [Quit: Leaving]
jonatack has quit [Ping timeout: 258 seconds]
jonatack has joined #lisp
<edgar-rft>
schweers: Edi Weitz wrote lots of stuff, mainly about math and most texts are in German, and you're right, it's surprisingly hard to find a list with all the stuff he wrote, or at least I have no link to offer :-(
<schweers>
I found some of his stuff on amazon, and yes, some of it is in german. Luckily, I understand german :)
Stanley00 has quit [Remote host closed the connection]
<Xach>
a secret power
<no-defun-allowed>
A useful skill for reading philosophy and Lisp books (same thing amirite).
orivej has quit [Ping timeout: 265 seconds]
orivej_ has joined #lisp
karayan has quit [Ping timeout: 260 seconds]
<ck_>
Excellent idea.. Schopenhauer Common Lisp
<easye>
no-defun-allowed: reading the French philosophers can be a little bit more fun.
EvW has joined #lisp
<no-defun-allowed>
Being able to read French also makes another range of Lisp and philosophy books available, yes.
* easye
can't read French, and can barely read German, so makes do with the English translations.
starch has quit [Quit: ERC (IRC client for Emacs 27.1)]
orivej_ has quit [Ping timeout: 260 seconds]
luckless_ has quit [Ping timeout: 240 seconds]
skapata has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
wsinatra has joined #lisp
Fare has joined #lisp
jw4 has joined #lisp
ayuce has joined #lisp
FreeBirdLjj has joined #lisp
Bike has joined #lisp
<dlowe>
just need to translate them all to lojban, the true lisp-like language
<dlowe>
otherwise you're stuck in an NxM translation matrix
treflip has quit [Ping timeout: 240 seconds]
toorevitimirp has quit [Ping timeout: 265 seconds]
treflip has joined #lisp
docl has joined #lisp
galex-713 has quit [Ping timeout: 258 seconds]
galex-713 has joined #lisp
dbotton_ has joined #lisp
dbotton has quit [Ping timeout: 240 seconds]
dbotton has joined #lisp
dbotton_ has quit [Ping timeout: 240 seconds]
galex-713 has quit [Ping timeout: 260 seconds]
galex-713 has joined #lisp
luckless_ has joined #lisp
schweers has quit [Ping timeout: 260 seconds]
toorevitimirp has joined #lisp
dbotton has quit [Ping timeout: 272 seconds]
ex_nihilo has quit [Ping timeout: 240 seconds]
yonkunas has joined #lisp
luis has quit [Ping timeout: 260 seconds]
Inline has joined #lisp
ayuce has quit [Remote host closed the connection]
achilles has joined #lisp
ldb has quit [Quit: ERC (IRC client for Emacs 26.1)]
achilles has left #lisp [#lisp]
bitmapper has quit [Quit: Connection closed for inactivity]
achilles has joined #lisp
kaftejiman has joined #lisp
toorevitimirp has quit [Ping timeout: 240 seconds]
<jackdaniel>
beach: I'm using flexichain now and its design is very elegant to me, thanks for this library
<beach>
Oh, great! Glad you like it!
enrio has joined #lisp
<beach>
I would have picked different names for the operators, had I done it today.
toorevitimirp has joined #lisp
<beach>
Maybe I can convince no-defun-allowed to create a version 2 with better names.
dbotton has joined #lisp
<jackdaniel>
names are fine, I don't think that it would be a good use of time (for it being a cosmetic issue)
<beach>
You may be right.
grumble is now known as Spooktober
kaftejiman_ has joined #lisp
kaftejiman has quit [Ping timeout: 256 seconds]
dbotton_ has joined #lisp
achilles has quit [Remote host closed the connection]
achilles has joined #lisp
dbotton has quit [Ping timeout: 260 seconds]
<jackdaniel>
I wonder if standard-cursorchain should be instantiable given not all flexicursor protocol functions are implemented for it (i.e cursor-pos) - unlike left/right-sticky-flexicursor
achilles has quit [Remote host closed the connection]
<beach>
I am afraid I don't remember enough of it to say.
pankajgodbole has joined #lisp
achilles has joined #lisp
tiwEllien has joined #lisp
EvW has quit [Ping timeout: 244 seconds]
dbotton_ has quit [Ping timeout: 256 seconds]
ft has quit [Ping timeout: 260 seconds]
ft has joined #lisp
davepdot_ has quit [Remote host closed the connection]
yonkunas has quit [Ping timeout: 240 seconds]
davepdotorg has joined #lisp
IAmRasputin has joined #lisp
Oladon has joined #lisp
kelamir[m] has quit [Ping timeout: 240 seconds]
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
yonkunas has joined #lisp
mjl has quit [Ping timeout: 244 seconds]
davepdotorg has quit [Read error: Connection reset by peer]
gaqwas[m] has quit [Ping timeout: 244 seconds]
ft has quit [Ping timeout: 240 seconds]
ft has joined #lisp
gaqwas[m] has joined #lisp
achilles has quit [Remote host closed the connection]
davepdotorg has joined #lisp
mjl has joined #lisp
entel_ has joined #lisp
<IAmRasputin>
Hello, I'm trying to write a function that prompts a user (me) for credentials to authenticate against an API, and it works, but it displays the password as I type it. I'd like it to not do this, either echoing nothing or echoing * in place of chartacters. Is it possible to implement this?
<phoe>
IAmRasputin: do you use a terminal?
<phoe>
or some other means of inputting data?
chewbranca has quit [Ping timeout: 244 seconds]
<phoe>
e.g. a slime repl?
<IAmRasputin>
phoe: mainly I use the slime repl, but eventually I'd like to use a plain terminal
<phoe>
in the slime REPL, I don't know if that's easily doable; you'd need to introduce some sort of modification to the slime-repl mode.
achilles has joined #lisp
<phoe>
in terminal, you'd possibly want to switch to a raw mode and start from there; I think cl-charms can help with that.
<IAmRasputin>
Great, I'll check that out. Thanks!
<IAmRasputin>
Eh, I was afraid of that, but I don't suspect that the slime REPL will be the primary means of interacting with this once it's "done"
<phoe>
it's not really a Lisp question per se; it's more of a question of how to interface with the terminal
XachX has quit [Ping timeout: 244 seconds]
chewbranca has joined #lisp
dra has quit [Remote host closed the connection]
XachX has joined #lisp
Necktwi has joined #lisp
yottabyte has quit [Ping timeout: 244 seconds]
thonkpod has quit [*.net *.split]
pent has quit [Ping timeout: 244 seconds]
entel has quit [*.net *.split]
cognemo has quit [*.net *.split]
boeg has quit [*.net *.split]
C-16 has quit [*.net *.split]
oldtopman has quit [*.net *.split]
entel_ is now known as entel
wglb has quit [Ping timeout: 240 seconds]
ecraven has quit [Ping timeout: 240 seconds]
cognemo has joined #lisp
C-16 has joined #lisp
oldtopman has joined #lisp
thonkpod has joined #lisp
mjl has quit [Ping timeout: 244 seconds]
boeg_ has joined #lisp
pent has joined #lisp
yottabyte has joined #lisp
l1x has joined #lisp
mjl has joined #lisp
kelamir[m] has joined #lisp
<mfiano->
Xach: Could you tell me why cl-digraph is so old in the dists? I've been waiting to use it for 4 months now, since the current dist version does not work on SBCL.
XachX has joined #lisp
ft has joined #lisp
<mfiano->
Xach: Oh, it seems maybe you need to point to its new home. I think sjl moved his repos back to GitHub. I don't see cl-digraph on his bitbucket anymore.
TwoNotes has joined #lisp
<TwoNotes>
Which Lisp GUI package has support for OTF fonts?
boeg_ has joined #lisp
<beach>
You may want to ask jackdaniel or scymtym, perhaps in #clim. They know stuff like that.
<beach>
TwoNotes: Depending on what you mean by "Lisp GUI package", there aren't that many specifically made for Common Lisp.
<TwoNotes>
All the ones I have found so far are just wrappers around Tcl, gtk, etc. That's fine.
<TwoNotes>
I just need to display text in a variety of fonts
<beach>
I use McCLIM to display Vietnamese text in large sans-serif fonts.
<beach>
If you want one of those, then I guess the font question has to do with those libraries, and not so much with Common Lisp.
wglb` has joined #lisp
<beach>
It can use TTF, but I don't know about OTF.
<mfiano->
An old issue says that McCLIM ignores OTF files. I'm not sure if that is still the case
* scymtym
is working on more complete OTF support
<beach>
scymtym: Thanks. It seems non-Lisp solutions are preferred.
<TwoNotes>
I will be working with the "sitelen pona" font, which makes use of some of the advanced OTF features.
<scymtym>
for McCLIM, the situation is like this, the ffi-based "harfbuzz"-based font rendering supports all the bells and whistles, the non-ffi-based font rendering supports a subset of OTF (TTF and TTC, but not CFF and WOFF)
<mfiano->
In any case, you can just use FreeType2 with CFFI, but that is not Lisp and I cannot really recommend that path
<TwoNotes>
I have to look where I got it from. A moment
<scymtym>
TwoNotes: is the font available for donwload?
<scymtym>
*download
<TwoNotes>
If yo udo not know some toki pona, it will not be greatly useful :)
<scymtym>
beach: i thought the information might be interesting to some anyway
<mfiano->
edgar-rft: It's completely broken and doesn't work
<beach>
scymtym: Certainly to me.
<scymtym>
TwoNotes: i can likely still see which OTF features it uses and maybe estimate how much work would be needed to support it
<TwoNotes>
There are two versions, depending on how you want to construct the glyphs
<mfiano->
The author has been unresponsive and hasn't kept up with the needed changes (currently he mis-manages foreign memory which results in constant memory corruption). One of many reasons why I cannot recommend a foreign library for such trivial tasks.
enrioog has joined #lisp
yottabyte has joined #lisp
l1x has quit [Ping timeout: 246 seconds]
XachX has quit [Ping timeout: 244 seconds]
Inline has quit [Ping timeout: 244 seconds]
ft has quit [Ping timeout: 256 seconds]
yottabyte has quit [Ping timeout: 244 seconds]
jprajzne has quit [Quit: Leaving.]
boeg_ has quit [Ping timeout: 244 seconds]
<edgar-rft>
The OTF Standard is from 1996, so it's too new for Common Lisp :-)
<TwoNotes>
It is more a matter of the graphics packages supporting it, not the language.
<phoe>
TwoNotes: edgar forgot a /s
<TwoNotes>
ha
dbotton has joined #lisp
<scymtym>
TwoNotes: that is true. adding the missing features on the font-format level seems doable. adding the missing features to the renderer could be harder
ft has joined #lisp
<scymtym>
(the fonts uses a CFF table which means, zpb-ttf cannot open it, but i already implemented most of CFF)
<scymtym>
sorry for the (more than usual) erratic typing. 6 hour video conference just ended
<beach>
Wow.
<mfiano->
Was it Lisp related? :)
enrio has quit [Ping timeout: 240 seconds]
kaftejiman_ has quit [Remote host closed the connection]
ft has quit [Ping timeout: 246 seconds]
achilles has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 258 seconds]
<scymtym>
i wish
<TwoNotes>
I have used the linja pona font in the libreOffice word processor and it works fine there. It is unusual in that takes entire words in text to make a single glyph.
FreeBirdLjj has quit []
<mfiano->
I've been trying to partake in more Lisp-related live streams. phoe's streams have been too early for me, but I try.
<mfiano->
That said, we do have a Lisp developer meetup this week (today) which typically runs 6 hours. But it is highly domain-specific so I doubt any of you would like to join :)
iamFIREc1 has quit [Quit: WeeChat 2.9]
toorevitimirp has quit [Remote host closed the connection]
sympt has joined #lisp
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
<jackdaniel>
it is worth to put emphasis (and scymtym said that) on the fact, that you may use McCLIM with the FFI library which fully supports otf
boeg_ has quit []
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
<TwoNotes>
Now after learning GTK for a different project, now I need to learn McCLIM.. oh well. I have the docs...
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
boeg_ has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
jmarciano has joined #lisp
boeg_ has quit [Client Quit]
davepdotorg has joined #lisp
boeg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
liberliver has quit [Quit: liberliver]
davepdotorg has quit [Read error: Connection reset by peer]
bitmapper has joined #lisp
davepdotorg has joined #lisp
<beach>
TwoNotes: McCLIM is being actively developed and maintained by jackdaniel, scymtym, and several others. I am sure they would be willing to assist you if you should have problems with it.
davepdotorg has quit [Read error: Connection reset by peer]
<TwoNotes>
I have a small test program currently written for GTK. I just need to adapt it to the new API.
<beach>
TwoNotes: Plus, by using McCLIM, you help expand the set of users, and who knows, maybe you will contribute to it as well.
ex_nihilo has joined #lisp
davepdotorg has joined #lisp
<TwoNotes>
And linja pona is practically a markup language so I am sure it will exercise a few new paths...
<TwoNotes>
For those not familiar with the notation, it is like a simplified Egyptian heroglyphics.
davepdotorg has quit [Read error: Connection reset by peer]
davepdot_ has joined #lisp
<TwoNotes>
Hieroglyphics. With compositing
<dlowe>
mi sona ona
<beach>
Interesting.
galex-713 has quit [Read error: Connection reset by peer]
galex-713_ has joined #lisp
<TwoNotes>
Such as, proper names go in a cartouche, which the font is capable of rendering
<TwoNotes>
(You cna write toki pona just fine with Latin letters, but this font is fun to work with
davepdot_ has quit [Quit: Leaving...]
choegusung has joined #lisp
<edgar-rft>
some day Lisp build its own pyramids
random-nick has joined #lisp
<phoe>
you mean balanced trees out of cons cells?
<edgar-rft>
maybe more like pyramid scheme :-)
<phoe>
:O
<mfiano->
Xach: Regarding your cl-digraph comment on GitHub, I failed to notice that he moved to his own Mercurial host. I am confused why it hasn't been updated since February.
<mfiano->
Quicklisp dist version that is. The commits in his Mercurial repository are much more recent
<Xach>
It was my mistake, I merged too late. It will be fixed in the next release.
<mfiano->
I only bring it up because the version tracked by QL is broken
<Xach>
The next release will use his new repo
<mfiano->
Ok thank you.
aeth has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
ljavorsk_ has quit [Ping timeout: 264 seconds]
Lord_of_Life has joined #lisp
mindCrime_ has joined #lisp
sammich has quit [Quit: Idle for 30+ days]
dbotton has quit [Ping timeout: 260 seconds]
DGASAU has quit [Read error: Connection reset by peer]
edgar-rft has quit [Quit: Leaving]
DGASAU has joined #lisp
mindCrime_ has quit [Ping timeout: 244 seconds]
mindCrime_ has joined #lisp
ex_nihilo has quit [Quit: Leaving]
TheInformaticist has joined #lisp
<TheInformaticist>
Have any of you read Anatomy of Lisp? If yes, what did you think of it?
<beach>
Great book.
<beach>
A bit old, but still quite good.
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
<TheInformaticist>
beach: What did you like about it?
<beach>
It was a while ago, but I remember the part about how to represent various aspects of an implementation, like environments, etc.
even4void has joined #lisp
<beach>
Starting with chapter 5 I guess.
<beach>
I mean, the previous chapters are good too, but the concrete description of the representation of various things was what taught me a lot.
enrioog has quit [Ping timeout: 260 seconds]
<mseddon>
yeah, they cover weizembaum environments and everything
<mseddon>
uh. weizenbaum*
jmarciano has quit [Ping timeout: 240 seconds]
<mseddon>
it is very oriented toward Lisp 1.5 though.
<beach>
I don't think much else existed at the time the book was written.
<mseddon>
maclisp did, but obviously it was totally inaccessible to most people
<mseddon>
(1978, says my copy here)
<beach>
Yeah, OK, so several Lisps existed. Maclisp and Interlisp.
<mseddon>
but the lisp at YOUR university was going to be a Lisp 1.5 derivative.
<mseddon>
so it's a good book, really.
<beach>
I was actually taught Lisp using some Interlisp variant, maybe around 1977 or so.
<beach>
And the research group then used Interlisp as well.
<mseddon>
was it as user friendly as it was made out to be? I find looking at interlisp source inpenetrable, but I've never really played with it.
<TheInformaticist>
beach: mseddon: Right. I notice in the bibliography it mentions a couple of the Lambda papers, and in the Preface he mentions Guy Steele. Man, was there anything that Guy Steele didn't leave his fingerprints on? He must be one of the most brilliant guys of the 20th century, and yet most don't know about him.
<mseddon>
TheInformaticist: GLS very importantly showed that you could do lexical binding efficiently, among other things.
<beach>
mseddon: We used only a small subset of it for a very short period of time. It might as well have been 1.5 or MacLisp for what we were doing.
<mseddon>
beach: ah right. that would make sens
<beach>
TheInformaticist: Oh, he is quite famous.
arpunk has quit [Ping timeout: 260 seconds]
<mseddon>
All hail the great Quux :)
<beach>
TheInformaticist: He was involved in Java, for instance.
<TheInformaticist>
beach: Yeah, I know. I'm a little disappointed in him for that. As he told the author of Anatomy of Lisp: That's not a compromise. That's a bloody surrender!
<mseddon>
TheInformaticist: he was hired because he'd already been in charge of two very successful standards, RnRs and Common lisp.
skapata has quit [Ping timeout: 272 seconds]
<mseddon>
But forces being what they are in the corporate world, I'm certain he got a lot of push-back to do anything too drastic.
<TheInformaticist>
Well, I'm sure he was well paid. I got the impression from remarks that he made in a talk that he felt his efforts with Lisp, especially Scheme, had been a failure.
Nilby has quit [Read error: No route to host]
skapata has joined #lisp
<TheInformaticist>
...because Common Lisp and Scheme did not go on to dominate the industry.
<tfb>
mseddon: Interlisp was user-friendly ... if you were one of the fair folk. But if you used it for long enough you became one, or at least got half way.
<mseddon>
tfb: right. I figured it must have been fairly decent, at least with the right tutoring
<mseddon>
learning an emulator for it is on my list, but gah, time.
ted_wroclaw has joined #lisp
arpunk has joined #lisp
<dlowe>
grumble grumble can't symbol-macrolet a special variable grumble
jurov_ is now known as jurov
ludston has quit [Read error: Connection reset by peer]
<tfb>
The Medley-revival project should be well-worth looking at (assuming you want to spend several years trapped in faerie. Which actuwll
<tfb>
... which actually seems quite appealing...
jprajzne has joined #lisp
gaqwas has quit [Ping timeout: 240 seconds]
oxum has joined #lisp
mindCrime_ has quit [Ping timeout: 240 seconds]
<mseddon>
I spent a good amount of time playing with MacLisp on ITS, so it's definitely on my list, particularly since it's so different from common lisp
<TheInformaticist>
mseddon: Really? How is it different?
<TheInformaticist>
mseddon: I honestly would like to know...I've wanted to know more about Maclisp since it inspired Emacs Lisp.
ym555 has quit [Ping timeout: 240 seconds]
<mseddon>
oh, maclisp is different is less ways from common lisp. No CLOS, obviously, a few names here and there, but interlisp is wildly different
<mseddon>
TheInformaticist: https://github.com/PDP-10/its/ this is where you can play with it if you like. Also includes EMACS on the PDP-10, all the good stuff. :)
<TheInformaticist>
mseddon: Oh, OK. Hey, that's cool :-) Thanks.
<mseddon>
np! careful, it's a black hole :)
ludston has joined #lisp
<tfb>
TheInformaticist: also Interlisp's idea of what a programming environment should be like -- a world where you edit list structure in memory and the filesystem is this incidental thing -- isjust wil
gareppa has joined #lisp
<tfb>
... is just wildly different to anything modern. (I need to stop typing on this crappy tablet, sorry)
<mseddon>
yeah, interlisp is all about a persistent environment. you are mostly modifying s-exprs directly. it's this whole crazy thing.
<TheInformaticist>
Ohhhhh, ITS! I've been stumbling across references to this for years! That's awesome.
srhm has quit [Read error: Connection reset by peer]
achilles has joined #lisp
<TheInformaticist>
tfb: mseddon: Emacs is kind of like that, wouldn't you say?
<mseddon>
no. emacs source files are still text. interlisps are literally the sexprs hanging off the fdefinition property list on a symbol.
<mseddon>
the editor edits an sexpr, not a text buffer.
<tfb>
No. Emacs is a cheap LispM, Interlisp was a whole other world.
<dlowe>
where do the comments go?
<TheInformaticist>
mseddon: I see. I'll have to try it out. Is Interlisp written in PDP-10 assembly?
<mseddon>
interlisp was ported across many platforms for many years.
<mseddon>
dlowe: they go on (COMMENT THIS IS TOTALLY UGLY)
<mseddon>
but I think tfb can probably clarify. basically you had some syntax that the evaluator ignore it I believe.
<dlowe>
I was thinking that's what it might be
<treflip>
Is there an object system in Interlisp?
<mseddon>
there was common LOOPS
<mseddon>
on which I think clos was partly based, the lispm guys were faffing around with flavors, which is single dispatch and a bit ugly
<TheInformaticist>
mseddon: Sorry. I was confusing Maclisp and Interlisp.
<mseddon>
ah, no, maclisp did not have an object system. lisp machine lisp added flavours, which symbolics also inherited.
<mseddon>
though genera added common lisp when it game out, I have no idea if knight etc also did.
<tfb>
treflip: PCL was Portable Common LOOPS, which came from Common LOOPS, which came from LOOPS. Many CLOS implementations have fairly direct PCL ancestry I think, still.
<treflip>
Cool
<mseddon>
aha. and yes, PCL does seem to regularly pop up when I peek into a CLOS implementation, in some weird form.
gravicappa has quit [Ping timeout: 246 seconds]
<tfb>
I wish I could remember the release names for PCL. Victoria day, Rainy day were two
achilles has quit [Remote host closed the connection]
<tfb>
(also for the interlisp-D releases: harmony, koto, lyric, medley are the ones I know. a rumour that the next one would be 'new wave')
rtypo has joined #lisp
gravicappa has joined #lisp
gareppa has quit [Quit: Leaving]
pankajgo` has joined #lisp
ludston has quit [Read error: Connection reset by peer]
pankajgodbole has quit [Ping timeout: 260 seconds]
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
niceplace has quit [Ping timeout: 264 seconds]
niceplace has joined #lisp
Steeve has joined #lisp
pankajgo` has quit [Ping timeout: 256 seconds]
frgo has joined #lisp
ludston has joined #lisp
IAmRasputin has quit [Ping timeout: 258 seconds]
<TheInformaticist>
OK, I know I'm probably going to get yelled at, but I'm interested to know: Did any of you ever use Niklaus Wirth's operating environment (I think it is called Oberon)? If yes, was there anything really revolutionary about it?
<mseddon>
yell. offtopic. it's interesting insofar as it's trivial to write, and the structured format of the grammar means you can translate it into static single assignment form extremely efficiently. Think of it as scheme for object-pascal / Modular 3. It's fun, the spec is like 50 pages long, go play. but. offtopic. :P
<mseddon>
uh. scheme to- it's still basically pascal, whatever way you look at it. yuck.
<TheInformaticist>
:-p Great answer. Thanks.
midre has quit [Ping timeout: 272 seconds]
IAmRasputin has joined #lisp
<TheInformaticist>
You know, I like Lisp and I like Pascal...for completely different reasons.
midre has joined #lisp
<TheInformaticist>
Although I can understand why Ken Thompson criticized Pascal. But it seems like most of the original C guys act like Lisp doesn't exist. They be like, "I don't know anything about that (Kernighan)."
IAmRasputin has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
achilles has joined #lisp
IAmRasputin has joined #lisp
akoana has joined #lisp
Oladon has quit [Quit: Leaving.]
drl has joined #lisp
ludston has quit [Read error: Connection reset by peer]
rtypo has quit [Ping timeout: 240 seconds]
drl has quit [Client Quit]
Alfr has joined #lisp
EvW has joined #lisp
ludston has joined #lisp
paul0 has joined #lisp
Sauvin has quit [Remote host closed the connection]
ramHero has quit [Remote host closed the connection]
zaquest has joined #lisp
ThaEwat has joined #lisp
achilles has quit [Remote host closed the connection]
MichaelRaskin has joined #lisp
krid has joined #lisp
TheInfor` has joined #lisp
jmarciano has joined #lisp
TheInformaticist has quit [Ping timeout: 256 seconds]
Oladon has joined #lisp
jmarciano has quit [Remote host closed the connection]
TheInfor` has left #lisp ["ERC (IRC client for Emacs 26.1)"]
<_death>
jackdaniel: nice.. I also used flexichain in my tui thingy
<_death>
oh, it was actually cluffer
frgo_ has joined #lisp
Colleen has quit [Remote host closed the connection]
Colleen has joined #lisp
jerme_ has quit [Ping timeout: 240 seconds]
sgithens has quit [Ping timeout: 240 seconds]
spacebat2 has quit [Ping timeout: 240 seconds]
banjiewen has quit [Ping timeout: 240 seconds]
jerme_ has joined #lisp
spacebat2 has joined #lisp
banjiewen has joined #lisp
sgithens has joined #lisp
frgo has quit [Ping timeout: 240 seconds]
Oladon has quit [Quit: Leaving.]
dra has joined #lisp
mindCrime_ has joined #lisp
Stanley00 has joined #lisp
Stanley00 has quit [Ping timeout: 240 seconds]
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
wsinatra has quit [Quit: WeeChat 2.9]
random-nick has quit [Read error: Connection timed out]
dra has quit [Remote host closed the connection]
Oladon has joined #lisp
random-nick has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
ted_wroclaw has joined #lisp
IAmRasputin has quit [Ping timeout: 258 seconds]
IAmRasputin has joined #lisp
IAmRasputin has quit [Ping timeout: 240 seconds]
pve_ has joined #lisp
scymtym has joined #lisp
wsinatra has joined #lisp
gravicappa has quit [Ping timeout: 240 seconds]
pve has quit [Ping timeout: 256 seconds]
ggole has quit [Quit: Leaving]
scymtym has quit [Ping timeout: 256 seconds]
kaftejiman has joined #lisp
scymtym has joined #lisp
kaftejiman has quit [Remote host closed the connection]
kaftejiman has joined #lisp
Inline has joined #lisp
pve_ has quit [Quit: leaving]
IAmRasputin has joined #lisp
narimiran has quit [Ping timeout: 260 seconds]
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
sympt_ has joined #lisp
kaftejiman has quit [Ping timeout: 264 seconds]
IAmRasputin has quit [Ping timeout: 260 seconds]
kaftejiman has joined #lisp
dominic34 has joined #lisp
dominic34 has quit [Excess Flood]
dominic34 has joined #lisp
jmarcian` has joined #lisp
<mseddon>
jackdaniel: that is the kind of LOC of integration code the world needs.
sympt has quit [Ping timeout: 272 seconds]
<mseddon>
jackdaniel: I'm curious, do you have your code up anywhere? It looks like a really fun, silly project. Love to see what you are doing under the hood.
jmarciano has quit [Ping timeout: 260 seconds]
mindCrime_ has quit [Ping timeout: 260 seconds]
karayan has joined #lisp
johs has quit [Ping timeout: 240 seconds]
johs has joined #lisp
luckless_ has quit [Ping timeout: 240 seconds]
shka_ has quit [Ping timeout: 240 seconds]
Oladon has quit [Quit: Leaving.]
sts-q has quit []
payphone54 has joined #lisp
Fare has quit [Ping timeout: 244 seconds]
gaqwas has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
Stanley00 has quit [Ping timeout: 260 seconds]
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
payphone54 has quit [Remote host closed the connection]
Fare has joined #lisp
akoana has left #lisp ["Leaving"]
tiwEllien has quit [Ping timeout: 260 seconds]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
fouric has joined #lisp
karlosz has quit [Quit: karlosz]
achilles has quit [Ping timeout: 260 seconds]
mindCrime_ has joined #lisp
IAmRasputin has joined #lisp
mindCrime_ has quit [Ping timeout: 240 seconds]
IAmRasputin has quit [Ping timeout: 260 seconds]
wsinatra has quit [Ping timeout: 240 seconds]
madage has quit [Remote host closed the connection]
wsinatra has joined #lisp
mindCrime_ has joined #lisp
Fare has quit [Ping timeout: 240 seconds]
Fare has joined #lisp
dominic34 has quit [Remote host closed the connection]