<dim>
ah, abcl, sometimes I'd like to produce a pgloader.jar for the JVM, and in that version use the JDBC drivers
<Fare>
fiddlerwoaroof, a more productive Lisp on the JVM is #clojure.
<Fare>
unless you specifically have a body of CL code to leverage there
<fiddlerwoaroof>
Yeah, I use clojure occasionally
<fiddlerwoaroof>
I don't like some of the language decisions, though
<Fare>
yeah, it has great stuff, and more questionable stuff.
<Fare>
Then again, there are JVM backends for Gambit and other well-maintained lisps.
<fiddlerwoaroof>
The company I work for has a significant amount of clojure code, although I'm not on one of the teams that works with it
<rpg>
IIRC there's a Scheme that is designed especially to be compiled into a Java program as an extension language. Is that maybe Kawa?
<fiddlerwoaroof>
Yeah
<fiddlerwoaroof>
But scheme isn't CL
<fiddlerwoaroof>
Among other things, I find Lisp-1s to be really annoying
Amplituhedron has quit [Ping timeout: 256 seconds]
raynold has joined #lisp
<rpg>
fiddlerwoaroof: I'm with you: that's why I used ABCL for my project.
<aeth>
Well, the choice is to either have a lisp-2 and require (funcall #'foo 42) which makes higher order functions less elegant or have a list-1 with tons of name collisions and make naming things less elegant (e.g. (define (foo l1st) ...) or (define (foo lst) ...) or (define (foo l) ...) when you can just (defun foo (list) ...) in CL)
<marvin3>
fiddlerwoaroof why?
<aeth>
s/list-1/lisp-1/
xenon- has joined #lisp
<fiddlerwoaroof>
marvin3: I don't like having to pick a name for variables/arguments based on whether or not there is already a function by the same name
<marvin3>
unless it is a function you actually use in that scope you can just shadow it with a variable name. so for less commonly used functions it isn't an issue
<aeth>
One possible alternative would be to break the language up into smaller packages, instead of having one big (:use :cl) so you don't have a name conflict
<fiddlerwoaroof>
For me, LIST is the most common instance of this
<aeth>
And yeah the problem mostly shows up with list in Scheme, especially since you use lists in Scheme more than in CL ime
<fiddlerwoaroof>
But, when I used to write python all the time, I'd frequently have bugs where I had accidentally shadowed a built-in function and then attempted to call it
<aeth>
Python isn't a good langauge for avoiding bugs.
<aeth>
It doesn't help that idiomatic Python is duck typing, too.
<rpg>
I could really use a common lisp with a type-checker, TBH. Wouldn't have to be brilliant, but would save me a lot of stupid bug time.
<aeth>
I use type declarations all of the time. Unfortunately, semantically, it won't type check on all implementations and in some implementations it will just type assume. On SBCL, it probably type assumes with (safety 0) but never do that.
<fiddlerwoaroof>
There are versions of shen written in CL
<aeth>
But at least type declarations help me in SBCL, where I develop
<fiddlerwoaroof>
I have no idea what cl<->shen interop is like
<fiddlerwoaroof>
But, I'd love to have a way to write blocks of code with ML-style type inference that seamlessly interoperate with CL
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
<aeth>
The problem with CL, or at least SBCL, is that functions (except when inlined) are basically barriers where all type information is lost unless you declare them all over again, for the most part. (or use the, which is very similar to declaring)
<aeth>
I would love to have full program type checking, that reruns if I change a function's signature in the REPL
<fiddlerwoaroof>
There are some really nice things in Haskell (e.g. return-type polymorphism) that would be nice to use in CL
<aeth>
I'm not even sure that full program type check warnings and type inference is impossible in CL. Just... track the functions.
<aeth>
Some more runtime overhead, but you kill most bugs
<rpg>
I was just reading an article about Instagram open sourcing some code that auto-generates type declarations from Python. I was wondering if something like that could be done for CL. But it actually depends on your code *running*, and if my code runs, then typically I don't have such bugs.
<aeth>
The CL problem is that (foo 42) might return a fixnum now, but it could be redefined in 10 seconds to return a single-float. Or a list.
<fiddlerwoaroof>
There are examples of that
<fiddlerwoaroof>
ACL2, for example, does fancy type checking on a subset of common lisp
<fiddlerwoaroof>
Of course, you have to treat everything that gets checked as a single compilation unit
<rpg>
Fare: I'm getting the XMLS release fixed up a bit, but I saw your MR. I am running the ASDF tests now. If they pass, I will merge.
josemanuel has quit [Quit: leaving]
<rpg>
aeth: My problem is that I like the SBCL compiler, but I like the ACL debugger.
<aeth>
What stops the implementation from rechecking if a function gets recompiled? It would just need to check users of #'foo when #'foo is recompiled, and then rerun those checks. Obviously, you wouldn't want that in the final program, but it could help before then.
<fiddlerwoaroof>
Yeah, I guess you could do that
<aeth>
I mean, SBCL already can use 100-200 MB, so what's another 100 MB in the era of 8+ GB?
<fiddlerwoaroof>
But it would mean that you couldn't arbitrarily redefine #'foo
<aeth>
fiddlerwoaroof: redefine #'foo, the data structure that tracks users of foo is checked, the type signature is found to be incompatible, warning happens
<aeth>
I guess one problem is that you wouldn't be able to use this for type inference in the final program to improve performance (e.g. automatically telling map which sequence it's working on)
<fiddlerwoaroof>
Also, nice type systems allow propagating all sorts of information that makes recompiling parts of the program less useful
red-dot has joined #lisp
<aeth>
fiddlerwoaroof: There are some parts of a program where treating every function as a T-returning black box makes sense. And then there are some, particularly in a hot loop, where you probably don't want that behavior.
<aeth>
And at the moment you're probably going to fill that part with the or declare to give type information, anyway.
<aeth>
Type information that could possibly be inferred if functions weren't the boundary for type inference
<aeth>
Types have two uses: catching bugs and performance. Everyone seems to focus on the first use these days.
<fiddlerwoaroof>
To me, the correctness-checking parts are the least interesting parts of a type system
<aeth>
If the compiler knows the types of everything, it can do magical optimizations to really make things run fast
<aeth>
Inferring immutability is probably afaik one of the most important things about a type.
<_death>
to me, types and type systems are something that's overblown to the point of being more harmful than useful
<aeth>
To me, I want software where everything that can be done before runtime is done before runtime. Types are helpful there. As are Lisp-style macros. And especially Lisp-style macros that know the type of things.
<_death>
today's fascination with reminds me of hammers and nails (of type T)
quazimodo has quit [Ping timeout: 265 seconds]
eschatologist has quit [Ping timeout: 276 seconds]
quazimodo has joined #lisp
<xenon->
_death did you have experience with more modern type systems, with type inference, etc? not the kind of types that exist in java/c++/c and friends
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<_death>
xenon: do you have experience with people who used such languages and aren't praying at that particular altar? :)
<fiddlerwoaroof>
There are a bunch of things I don't like about a language like Haskell, but the way you can use the type system to propagate information about your program at compile time is really cool
<aeth>
_death: It depends on what kind of problem you're solving.
<xenon->
_death what language did you try and what was your main objection?
jameser has joined #lisp
<_death>
aeth: well, I am a bit of a generalist so I solve all kinds of problems :)
<aeth>
_death: If you have a long-running loop, you want all of the work done ahead of time that you can get away with. If you're using the language as a Unix script, it might not be worth the time.
<_death>
xenon: I wouldn't like to discuss it here.. it is off topic anyway
<rpg>
aeth: got to go, but one thing -- I think there are two very different purposes for type systems. One is to help with correctness, for which you need very thorough type inference, and complex types (or, as in Java, the types don't help you get correctness). The other is type information to allow the compiler to do magical things. It's not clear to me that there's a type system that gives you both.
quazimodo has quit [Ping timeout: 265 seconds]
<aeth>
rpg: Well, you give the behavior you want, the compiler (or the macro with type information!) decides the fastest route it knows that produces equivalent results. So you want both a magical compiler and correctness.
rumbler31 has joined #lisp
pedh has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
<aeth>
I guess you can have a type system that provides one and not both
<aeth>
In SBCL, what limited type information you can give provdies both afaik. e.g. disassemble something with and without type declarations, especially if it's dealing with numbers or sequences.
<_death>
apropos, I thought Guy Steele made a good joke when he asked about those formalisms type theorists like so much, which are expressed in first-order logic, which is untyped..
ezgoat has joined #lisp
<fiddlerwoaroof>
With a haskell-style type inference, you wouldn't need the result-type argument of map, but (aref (map #'+1 '(1 2 3)) 0) and (car (map #'+1 #(1 2 3))) would both work
pedh has quit [Ping timeout: 256 seconds]
<aeth>
fiddlerwoaroof: you need the result type in CL because you can say (map 'list #'+ 'some-vector 'another-vector)
<fiddlerwoaroof>
Yes, in haskell the type system would realize that #'aref takes a vector and automatically pick the right implementation of map
<fiddlerwoaroof>
(e.g. the one that returns a vector)
caffe has joined #lisp
<caffe>
o/
<aeth>
fiddlerwoaroof: But aref is generic over all arrays. The compiler will know you want a 1D array, and nothing more. Do you want a T array or an array of the most specific type it can use (e.g. '(unsigned byte 8) or something) or the most general not-T type it can use (e.g. 'fixnum or something)?
<aeth>
Although, if it's discarded right away, I guess it doesn't matter
<fiddlerwoaroof>
In theory, it could pick svref when appropriate
<aeth>
But you could think up an example where you both do the aref and then e.g. return the array too
<fiddlerwoaroof>
The idea is that, since the compiler knows what type your result is supposed to have, it can use that information to do generic function-like dispatch, at compile time
<marvin3>
haskell does the same thing with literals. 1 is of Num a => a type, which can, depending on a context, be Int, Integer, Double, or any other type that implements Num
<fiddlerwoaroof>
Yeah, this is why I want to have a little common lisp DSL that does haskell-style type checking
<_death>
meanwhile, if I want fast code I can generate assembly in Lisp, or write opencl code, or write a C module or whatever..
<aeth>
fiddlerwoaroof: I think you can do that in CL, if the macro system knows the type information and you write the right macro. Iirc, type information in macros was proposed but rejected.
<caffe>
i'm having a bit of a stumper regarding sb-ext:run-program... i can get it to run one-liners, but despite :input *standard-input* :output *standard-output*, i can't get it working for anything that has interactive prompts
<fiddlerwoaroof>
aeth: yeah, it's perfectly possible to write a macro that embeds such a dsl
<aeth>
_death: Ideally, you don't want to directly write assembly, you want to have a conversation with the compiler to try to produce the correct (disassemble #'foo) result automatically. Then it stays portable, but slow, in other circumstances and you probably save effort anyway.
<aeth>
Unfortunately, it only supports SBCL, CCL, and CMUCL. If ECL supported the ncessary features, too, that would make a huge difference.
<fiddlerwoaroof>
Yeah, I think the common lisp type system is too powerful for good type inference :)
<aeth>
_death: A compiler with enough information will generate better assembly than you can write by hand. The problem is when the compiler doesn't have enough information.
<fiddlerwoaroof>
My goal would be to support a useful subset of the type system
<_death>
aeth: sorry, that's wrong
<aeth>
_death: Then you must be a good assembly programmer.
<fiddlerwoaroof>
compilers can't actually use vector instructions very well, as I understand
<_death>
aeth: it's the myth of the sufficiently-smart compiler
<aeth>
fiddlerwoaroof: I suspect that that's a problem with C being high-level PDP-7 assembly and not really matching modern hardware too well.
<fiddlerwoaroof>
I think auto-vectorization, like auto-parallelization is a surprisingly hard problem
<aeth>
_death: A compiler can only work with what it's given.
<_death>
aeth: sometimes it's enough just to be able to generate the instructions you need for the particular case..
<aeth>
fiddlerwoaroof: But in something like Lisp, you don't need auto-vectorization, you can make anything look like it was a built-in part of the language. Auto-vectorization is afaik more like C programmers wanting to stick to their increasingly-outdated for loops.
<_death>
aeth: you have all the control you need then, and an assembler is much faster than an optimizing compiler as well
EvW1 has quit [Ping timeout: 265 seconds]
<aeth>
Make a language where the problem isn't hard, rather than trying to make C-style semantics do something totally alien to the PDP-7 it was designed for.
<Xach>
caffe: hey! did you have any luck?
<caffe>
not yet, no
<Xach>
caffe: i have had some luck by using a pty
<Xach>
caffe: out of curiosity, what interactive program are you trying to run?
<caffe>
ahh, good idea..
greaser|q has quit [K-Lined]
brandonz has quit [K-Lined]
<caffe>
not any one in particular... mostly a set of bash scripts that prompt for a few lines of input and exit
<Xach>
I'm actually thinking of making something expect-like for sbcl's run-program pty stuff.
brandonz has joined #lisp
<Xach>
I love running external programs to save time and effort.
greaser|q has joined #lisp
<caffe>
they work similar in fashion to adduser scripts, etc
* Xach
would often rather run an external program than work out C bindings
<_death>
caffe: maybe it's an issue of buffering?
<caffe>
so i need to find a way to identify what pty the user is on, i'm guessing?
dddddd has quit [Read error: Connection reset by peer]
<fiddlerwoaroof>
caffe: no, you need to open a pty and start the interactive program in it
<caffe>
ah, okay.
<Xach>
caffe: no, just use the :pty argument to run-program and you will have a lot lower-level control over input and output of the process
<Xach>
No, sb-ext:run-program shields you from direct pty management.
<caffe>
now here's the tricky part... can this be done in clim-listener?
<fiddlerwoaroof>
Yeah
<caffe>
awesome, i'll give that a try
<pjb>
type /ignore bubbaw574
<Xach>
fiddlerwoaroof: you don't need to directly open a pty, run-program does it on your behalf.
mepian has quit [Quit: Leaving]
<fiddlerwoaroof>
Cool, I just meant to say that you don't need to get the user's pty, you just start your own---implicitly or explicitly
pedh has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
zooey has quit [Ping timeout: 248 seconds]
nowhere_man has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
pedh has quit [Ping timeout: 256 seconds]
eschatologist has joined #lisp
aindilis has joined #lisp
zooey has joined #lisp
<caffe>
is it just :pty, or do i need an argument/variable after that?
jack_rabbit has quit [Quit: Leaving]
groovy2shoes has quit [Quit: moritura te saluto]
fikka has quit [Ping timeout: 240 seconds]
tom34 has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof>
caffe: the documentation says "T nil or a stream"
<caffe>
ah, thank you.. can you refer me to this doc?
<fiddlerwoaroof>
Does anyone know if lispworks automatically adds (:use :cl) to a defpackage without any (:use...) clause)
<fiddlerwoaroof>
?
<fiddlerwoaroof>
(don't have my laptop with lispworks handy)
tom34 has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
<caffe>
ugh, still not having luck with this
<caffe>
(run-program "/bin/program" '() :input *standard-input* :output *standard-output*) gets the farthest, but fails at the first interactive prompt of the program being run
fikka has joined #lisp
<malice>
caffe: any interactive program?
<fiddlerwoaroof>
Are you trying to write a terminal caffe?
<caffe>
(run-program "/bin/program" '() :pty t) yields no output at all
nowhere_man has quit [Remote host closed the connection]
<fiddlerwoaroof>
Even in the terminal, it shows the output, but doesn't really respond to input
Kundry_Wag has quit [Ping timeout: 272 seconds]
nowhere_man has joined #lisp
<malice>
well, for me, if working with sbcl, if I create a code.lisp (run-program "/bin/echo" nil) and then run it like "sbcl --load code.lisp" - it will work
Karl_Dscc has quit [Remote host closed the connection]
<caffe>
clim listener or sbcl in a terminal
fikka has quit [Ping timeout: 260 seconds]
<malice>
does this work for you?
<malice>
for clim - I remember trying to debug something in there with *standard-input* and *standard-output*, and it looked like they were changed somehow
<malice>
so e.g. #'print wouldn't print anything to standard-output, at least with slime, but slime changes *standard-output* too
<fiddlerwoaroof>
CLIM-LISTENER probably rebinds them to the listener pane
dieggsy has quit [Ping timeout: 255 seconds]
<malice>
I mean, if the simple "echo" program works for you in SBCL then other programs should work too
moei has quit [Quit: Leaving...]
<caffe>
echo works, but read doesn't seem to
<malice>
caffe: read as in CL's function?
<malice>
could you share the code?
<fiddlerwoaroof>
Yeah, input doesn't seem to work
<caffe>
no, as in when a bash script i'm trying to execute (or just read itself) just goes nowhere. it doesn't respond to input
<malice>
fiddlerwoaroof: you can use "nil" or just () instead of this quoting abomination
<fiddlerwoaroof>
:)
<fiddlerwoaroof>
I do this habitually when using the shell, can't help it :)
moei has joined #lisp
<caffe>
now, one more question... is there a way to do this and have it return to sbcl's prompt upon exiting?
<caffe>
instead of exiting sbcl
<malice>
Hmm.
tom34 has joined #lisp
<malice>
If I run the bin/python example and then call quit() in Python, it returns to REPL just fine
<malice>
maybe you aren't in a loop or something?
<malice>
fiddlerwoaroof: this *might* have something to do with "If t, the standard output for the current process is inherited." bit (I'm guessing though)
<caffe>
i just started sbcl from the shell
<caffe>
then ran the command, exited the program launched, and got dumped back to bash
turkja has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
<caffe>
i'll try it in the listener and see what happens
<fiddlerwoaroof>
I think yeah, there is some magic going on in the source
<caffe>
ah. it started the application in my toplevel
<caffe>
and yeah, kicks me out after exiting that application
<malice>
caffe: then I don't really know what to do. (run-program "usr/bin/python" nil :input t :output t) pasted into SBCL after running "sbcl" command
nowhere_man has quit [Read error: Connection reset by peer]
<malice>
and then running "quit()" sends me back to CL's REPL just fine
tom34 has quit [Ping timeout: 256 seconds]
nowhere_man has joined #lisp
igemnace has joined #lisp
pjb has quit [Quit: Good night.]
<caffe>
ahh, caught it
<caffe>
it's because i'm using '() instead of nil
<malice>
:D
<malice>
Told you!
d4ryus2 has joined #lisp
<caffe>
hm, still kicks me out
<caffe>
that has to be a different problem though
<fiddlerwoaroof>
it's really annoying to me that the python library cffi interferes with the lisp one in google search results
d4ryus1 has quit [Ping timeout: 240 seconds]
<caffe>
yeah, that's not run-program, that's a problem with the script i'm executing
<caffe>
and not a lisp problem
moei has quit [Quit: Leaving...]
<wigust_>
fiddlerwoaroof: It's like with C and C++/#/Object. Maybe -python will help.
fikka has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
pierpa has quit [Quit: Page closed]
fikka has joined #lisp
tom34 has joined #lisp
astronavt has quit [Remote host closed the connection]
tom34 has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 264 seconds]
pmetzger has quit []
aindilis has quit [Ping timeout: 256 seconds]
aindilis` has joined #lisp
astronavt has joined #lisp
rumbler31 has quit [Remote host closed the connection]
fikka has joined #lisp
red-dot has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 265 seconds]
damke has joined #lisp
kolb has quit [Read error: Connection reset by peer]
mrottenkolber has joined #lisp
pedh has joined #lisp
mrottenkolber is now known as Guest26689
damke_ has quit [Ping timeout: 264 seconds]
bagnalla has joined #lisp
fikka has joined #lisp
pedh has quit [Ping timeout: 264 seconds]
bigos_ has quit [Remote host closed the connection]
nullman has quit [Quit: leaving]
nullman has joined #lisp
astronavt has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 265 seconds]
astronavt has joined #lisp
astronavt has quit [Remote host closed the connection]
malice has quit [Remote host closed the connection]
fikka has joined #lisp
kark has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
tom34 has joined #lisp
fikka has joined #lisp
dieggsy has quit [Remote host closed the connection]
tom34 has quit [Ping timeout: 240 seconds]
LiamH has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
rumbler31 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
yangby has joined #lisp
rumbler31 has quit [Remote host closed the connection]
Zakkor has quit [Quit: Connection closed for inactivity]
rumbler31 has joined #lisp
PuercoPope has joined #lisp
PuercoPope has quit [Client Quit]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
dieggsy has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
schoppenhauer has quit [Ping timeout: 265 seconds]
schoppenhauer has joined #lisp
ahungry has joined #lisp
Bike has quit [Quit: Lost terminal]
milanj has quit [Quit: This computer has gone to sleep]
dieggsy has quit [Remote host closed the connection]
_main_ has joined #lisp
fikka has joined #lisp
tom34 has joined #lisp
__main__ has quit [Ping timeout: 255 seconds]
_main_ is now known as __main__
<beach>
Good morning everyone!
fikka has quit [Ping timeout: 256 seconds]
tom34 has quit [Ping timeout: 265 seconds]
pedh has joined #lisp
Vicfred has joined #lisp
fikka has joined #lisp
bagnalla has left #lisp [#lisp]
pedh has quit [Ping timeout: 265 seconds]
damke_ has joined #lisp
milanj has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
damke has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
impulse has quit [Quit: leaving]
<nydel>
morning beach hope you're well
<beach>
Yes, thank you. You too I hope.
nalkri has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
kartik has joined #lisp
EvW has joined #lisp
kark has quit [Ping timeout: 248 seconds]
raphaelss has quit [Ping timeout: 272 seconds]
holycow has joined #lisp
impulse has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
kartik has quit [Quit: WeeChat 1.4]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 272 seconds]
dieggsy has joined #lisp
raphaelss has joined #lisp
pedh has joined #lisp
zooey has quit [Ping timeout: 248 seconds]
zooey has joined #lisp
fikka has joined #lisp
pedh has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Remote host closed the connection]
dieggsy has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
shka has joined #lisp
tom34 has joined #lisp
BitPuffin|osx has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
tom34 has quit [Ping timeout: 265 seconds]
quazimodo has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dcluna has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
pedh has joined #lisp
ahungry has quit [Remote host closed the connection]
pedh has quit [Ping timeout: 264 seconds]
tom34 has joined #lisp
mishoo_ has joined #lisp
fikka has joined #lisp
tom34 has quit [Ping timeout: 248 seconds]
milanj has quit [Quit: This computer has gone to sleep]
fikka has quit [Ping timeout: 240 seconds]
atgreen has quit [Quit: atgreen]
fikka has joined #lisp
atgreen has joined #lisp
raphaelss has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
<drmeister>
::notify shiho - pull clasp, cando and the master branch of quicklisp/cl-jupyter and rebuild everything. I fixed the python crashes when evaluating cells in Jupyter notebooks. It was a threading problem.
<Colleen>
drmeister: Got it. I'll let shiho know as soon as possible.
<drmeister>
::notify Kevslinger - pull clasp, cando and the master branch of quicklisp/cl-jupyter and rebuild everything. I fixed the python crashes when evaluating cells in Jupyter notebooks. It was a threading problem.
<Colleen>
drmeister: Got it. I'll let Kevslinger know as soon as possible.
<beach>
Do they come to #lisp?
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
dec0n has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
d4ryus2 is now known as d4ryus
fikka has quit [Ping timeout: 264 seconds]
moei has joined #lisp
flamebeard has joined #lisp
greaser|q has quit [Changing host]
greaser|q has joined #lisp
greaser|q is now known as GreaseMonkey
moei has quit [Client Quit]
moei has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
hajovonta has joined #lisp
<hajovonta>
hello all
<Shinmera>
beach: Notes are per-server, so it doesn't matter.
knobo1 has joined #lisp
tom34 has joined #lisp
fikka has joined #lisp
pdv has joined #lisp
oleo has quit [Quit: Leaving]
Amplituhedron has joined #lisp
tom34 has quit [Ping timeout: 260 seconds]
knobo1 has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 256 seconds]
quazimodo has quit [Ping timeout: 265 seconds]
hajovonta has quit [Remote host closed the connection]
fikka has joined #lisp
khisanth_ has quit [Ping timeout: 256 seconds]
<beach>
Shinmera: Got it.
Mon_Ouie has joined #lisp
nirved has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Mon_Ouie has quit [Read error: Connection reset by peer]
khisanth_ has joined #lisp
mingus has quit [Remote host closed the connection]
shenghi has quit [Remote host closed the connection]
trittweiler has joined #lisp
shenghi has joined #lisp
shenghi has quit [Remote host closed the connection]
shenghi has joined #lisp
shenghi has quit [Read error: Connection reset by peer]
shenghi has joined #lisp
shenghi has quit [Remote host closed the connection]
shenghi has joined #lisp
varjag has joined #lisp
nydel has quit [Read error: Connection reset by peer]
scymtym has joined #lisp
raphaelss has joined #lisp
fikka has joined #lisp
rippa has joined #lisp
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jameser has joined #lisp
tom34 has joined #lisp
shka has quit [Ping timeout: 264 seconds]
tom34 has quit [Ping timeout: 255 seconds]
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
malcom2073 has quit [Quit: No Ping reply in 180 seconds.]
malcom2073 has joined #lisp
malcom2073 has quit [Client Quit]
damke has joined #lisp
schweers has joined #lisp
malcom2073 has joined #lisp
Younder has joined #lisp
dec0n has quit [Quit: Leaving]
damke_ has quit [Ping timeout: 264 seconds]
hhdave has joined #lisp
dec0n has joined #lisp
hajovonta has joined #lisp
schweers has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
Nathan has joined #lisp
sunwukong has joined #lisp
Nathan is now known as schweers
milanj has joined #lisp
Amplituhedron has quit [Ping timeout: 256 seconds]
sword` has quit [Read error: No route to host]
Murii has joined #lisp
tom34 has joined #lisp
TMA has quit [Quit: leaving]
TMA has joined #lisp
knobo1 has joined #lisp
Karl_Dscc has joined #lisp
tom34 has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
ezgoat has quit [Ping timeout: 272 seconds]
Tobbi has joined #lisp
kris has joined #lisp
mingus has joined #lisp
red-dot has joined #lisp
holycow has quit [Quit: Lost terminal]
scymtym has quit [Ping timeout: 265 seconds]
pedh has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pedh has quit [Ping timeout: 255 seconds]
* beach
had a crap morning, dedicated to admin chores.
<loke>
beach: !
* loke
misread "dedicated" as "defecated"... Hmm...
<loke>
Puts another spin on a crap morning...
* loke
has been wriing some Elixir this morning.
<beach>
Dr Freud might have something to say about that misreading.
<loke>
beach: No need to invoke him. I'm not ashamed of the fact that I still find toilet umour incredibly funny.
<loke>
humour
<beach>
Yes, I see.
quazimodo has joined #lisp
<loke>
I'm also listening to Swedish metal music now: 𝅘𝅥𝅮 Strykjärn - Länsmansdjävul 𝅘𝅥𝅮
<beach>
That should be good.
<beach>
Let me see if there is anything on YouTube...
<beach>
You need to let me finish listening to the first one.
<loke>
Sure :-)
<loke>
That first virdeo is so... Swedish :-)
yangby has quit [Quit: Go out for a walk and buy a drink.]
<beach>
Boy, band members are such good instrumentalists these days. A few decades ago, they were mostly just bad.
<beach>
Thanks for the links!
* beach
tries to get some useful work done for the rest of the day.
<dim>
well in my experience pop music band players have always been quite good, but you would typically pay no attention to them, only to the front man
<pjb>
Murii: the trick is to take the chapters of clhs, and to read all the section but the dictionary. Just browse the dictionary to have an idea of what's available. Then when you look for a function, go to the chapters relevant to your question (eg. here, you would search in the Conses, Arrays, Strings and Sequences chapters), and look in their dictionaries for the function you want.
<mfiano>
Aha. Is it true that vlime does not give you a REPL to type into?
<sjl>
correct, you send text from a scratch buffer and review the results in a separate buffer
nalkri has quit [Ping timeout: 272 seconds]
<sjl>
I like having a repl, so I use neovim's terminal emulator to launch the lisp process
<sjl>
and use that as my repl
<mfiano>
That is odd.
<mfiano>
Ok.
<sjl>
Vim has never really supported the "some parts of the buffer are modifiable but not others" model
akkad has joined #lisp
<sjl>
slimv tried to do that for its lisp repl, but it was a buggy mess
<sjl>
vlime doesn't bother attempting, and instead works with Vim's normal workflow
<mfiano>
I used slimv for about 6 years before I moved to Emacs, but I am getting reacquainted with [n]vim recently.
<sjl>
I've found vlime to work much better than slimv
<sjl>
so it might be worth trying
<mfiano>
I haven't looked into the documentation for nvim's terminal yet, but at quick glance, it doesn't let me enter normal mode
<mfiano>
Which is going to take some getting used to, to perform the usual operators.
<sjl>
It does, it just has a different shortcut
<sjl>
because <esc> is a useful key in many things you might want to run in a terminal
<sjl>
you can bind it back to <esc> if you want (I do)
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
<mfiano>
So what do you do to get a terminal running your implementation's REPL in the same context as the code you are sending to vlime's internal REPL?
<mfiano>
or am I misunderstanding?
<sjl>
so, the general idea with SLIME/SWANK is that you run a lisp process and fire up a swank server inside it, which listens for incoming connections
<sjl>
then in your editor, emacs/vim/whatever you connect to that server over tcp or whatever
<sjl>
in my case, I'm doing this, but I happen to be starting the Lisp process from within a Neovim split
<sjl>
instead of in a different terminal window or whatever
<mfiano>
I see. I'll look into this. It's going to take me some getting used to away from Sly though (a more featureful SLIME).
<sjl>
if you're already comfortable in emacs it's probably not worth it
<sjl>
but I can't get Vim out of my fingers at this point (evil mode was a pale imitation last time I tried it) so I make due with vlime
Xal has quit [Ping timeout: 256 seconds]
<sjl>
the real solution would be for me to take a year off and make my own terminal/ncurses editor in CL
<mfiano>
I am, but it's not practical on one of my devices (an old netbook which I don't even like running Xorg on due to the memory restrictions)
<sjl>
ah
<mfiano>
So I have migrated to vim for all other development there.
<sjl>
a/b 4
<sjl>
whops
milanj has quit [Quit: This computer has gone to sleep]
Murii has quit [Quit: WeeChat 1.4]
warweasle_afk has quit [Quit: rcirc on GNU Emacs 24.4.1]
<mfiano>
I have a lot of experience developing CL in both editors, but I also prefer vim, mainly because it uses far less resources, and is very snappy on old hardware.
<mfiano>
I just haven't tried vlime, but I am thinking about it now :)
<rumbler31>
hmm
Xal has joined #lisp
Achylles has joined #lisp
earl-ducaine has quit [Remote host closed the connection]
<rumbler31>
minion: memo for jmercouris: count me in for reviewing
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
earl-ducaine has joined #lisp
angavrilov has quit [Remote host closed the connection]
Cymew has joined #lisp
<jfb4>
sjl: so to deploy in production on a remote server, would you use the same mechanics of having swank running on remote?
Karl_Dscc has quit [Read error: Connection reset by peer]
brendyn has joined #lisp
Karl_Dscc has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
nalik891 has joined #lisp
nullniverse has quit [Read error: Connection reset by peer]
nalik891 has quit [Client Quit]
jmercouris has joined #lisp
<jmercouris>
mfiano: Any idea for the name of the group?
<minion>
jmercouris, memo from sjl: I'd join a review group. sjl on github.
<minion>
jmercouris, memo from rumbler31: count me in for reviewing
<jmercouris>
Ok, I will add you two as well
<mfiano>
Nope, I assumed one already existed
<jmercouris>
None exists, I have to think of a good name, marketing is everything :P
<jmercouris>
How about "Common Lisp User Group"?
<aeth>
How does that differ from sharplispers?
<phoe>
jmercouris: which group?
<jmercouris>
CLPRG = Common Lisp PR Group
<phoe>
PR as in public relations?
<jmercouris>
phoe: I'm trying to organize a group of people on github to fork/share responsibility in accepting/reviewing PRs from orphaned repositories
<phoe>
jmercouris: gotcha. why isn't sharplispers good enough?
<jmercouris>
phoe: Perhaps they are, 1. I did not know they exist 2. the more the merrier
<jmercouris>
Is that what sharp lispers does?
smurfrobot has joined #lisp
<jackdaniel>
I've never heard that it's an orphanage (until recently)
KarlDscc has joined #lisp
Karl_Dscc has quit [Ping timeout: 264 seconds]
<jmercouris>
jackdaniel: I assume you are correct about it's purpose, therefore this would seem to serve a different one
<jmercouris>
Name suggestions?
<jmercouris>
so far I am a huge fan of CL User Group
<jackdaniel>
lisp gardeners?
<jmercouris>
gardeneres while accurate, doesn't convey the image we want
eudoxia has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
<Xach>
jmercouris: sharplispers is for adopting and maintaining orphaned projects.
<Xach>
We make sure they remain accessible and merge patches and make occasional changes.
<jmercouris>
Xach: I see, so perhaps this is the group to join after all
<jmercouris>
what are your application requirements?
<jmercouris>
Xach: What are your criteria for forking/accepting new projects? What is your process?
<Xach>
jmercouris: if someone notices a project with no maintainer, or a maintainer who is actively giving up maintenance, we will add it to sharplispers on github.
<Xach>
There isn't much process. Sometimes it is done by email. Sometimes it is done through issues or irc.
<Xach>
If someone wants to join and do it, they can do it.
shka has quit [Quit: Konversation terminated!]
<jmercouris>
Xach: What is the literal process to join
shka has joined #lisp
<jmercouris>
Xach: Does someone contact you? and then you just add them?
<Xach>
jmercouris: "can i join sharplispers" and i respond "ok, what is your github user id" and then i do it.
<jmercouris>
Xach: can i join sharplispers? can you also make me an admin so that I may add new people?
gtuser has quit [Quit: gtuser]
<Xach>
In this case, I missed some context. Why do you want to join? Is there a specific project?
<jmercouris>
Xach: I see that there is a need for this project to be bigger
<jmercouris>
It needs more inertia and it needs to be self sustaining
<phoe>
jmercouris: 2) "the more the merrier" doesn't work
<Xach>
jmercouris: what project?
<jmercouris>
Xach: Sharplispers
<phoe>
jmercouris: then come join them and push together with them
<phoe>
creating inertia in project A doesn't happen by pushing projet B
<jmercouris>
phoe: Yes, this is the discussion Xach and I right now, I am asking him to join the group with admin rights so I may add people
<Xach>
jmercouris: Is there a specific orphaned project you wish to maintain via sharplispers?
<jmercouris>
Xach: I can think of one yes, cl-string-match
<jmercouris>
Must I have a specific project in mind though?
<Xach>
jmercouris: It would help. The goal of sharplispers is not to grow and expand sharplispers, but to keep useful things from falling entirely by the wayside into neglect.
rmrenner has joined #lisp
shka has quit [Ping timeout: 240 seconds]
<jmercouris>
Xach: In order to satisfy goal 1: Keep useful things from falling entirely by the wayside into neglect, it is necessary to 2. Have a large community of members that can sustain themselves over time and maintain a consistent knowledge pool
<jmercouris>
When you have such a small group of only 8 people, it only takes the loss of a few members for the percent churn to be so great that so much knowledge is immediately lost
<galdor>
from an outsider who has barely the time to hack some lisp for fun, I'm much more concerned about maintaining quality than having more developers
<galdor>
especially when there are sensible projects such as ironclad
<jmercouris>
galdor: This isn't about expanding and developing new projects, one doesn't need to be an expert Lisper to review PR fixes and tests
<jmercouris>
Of course one must always be careful to avoid misstep, but it is certainly an easier task than programming novel systems
<jmercouris>
Xach: Sharplispers to me sounds more like a guild than anything else the way you are describing it
tom34 has joined #lisp
<galdor>
of course one can always send PR, as for any other github project
<sjl>
jfb4: if I wanted the thing to be debuggable in production, I could run a swank server in the production process and just make absolutely sure it's only listening on localhost, yes
<sjl>
probably firewall the port with iptables just to be sure
<jmercouris>
galdor: Yes, and what about when users do not respond to PRs as they often do?
<rumbler31>
sjl: I think by default its listening on localhost, you need to explicitly change a global to make swank listen on a specific interfaces
<sjl>
rumbler31: I would hope so, yeah
fourier has quit [Ping timeout: 256 seconds]
<rumbler31>
sjl: I should have said "is" rather than "I think"
<galdor>
jmercouris: been there, done that, this is indeed frustrating
<sjl>
the only stuff I've "deployed" in CL so far has been some games running under a telnet server. for those I just disable the debugger entirely -- if they crash oh well
<galdor>
I now just fork what I need, and add everything as submodules in my "site-lisp" repository
tom34 has quit [Ping timeout: 240 seconds]
<galdor>
as long as the license matches of course
<Xach>
jmercouris: Maybe a guild is a good description. The existing people are those who know and trust each other. People who have asked to join have had a good reputation and history.
<galdor>
in general you cannot really expect your PR to be merged as fast as you need it (i.e. right now), so having your fork and sending the PR separately seems to be a good idea
<jmercouris>
Xach: Then what you have, and what I would like to have are two different concepts, groups with a similar mission, but I would like to be significantly more inclusive
<Xach>
jmercouris: Ok
<jmercouris>
I also don't like the idea of fragmenting the community more though
<Xach>
jmercouris: Would you still like to be added, and add cl-string-match and maintain it?
<Xach>
jmercouris: can you tell me more about the neglect of cl-string-match? Its author seems to be recently active on other projects.
<jfb4>
sjl/rumbler31:thanks!!
<rumbler31>
what did I do
<jmercouris>
Xach: Yeah, there's a several compiler warnings when loaded, and some incomplete sections of the API IIRC
<jmercouris>
Let me gist a compilation log, one second
<jmercouris>
sjl: True, it doesn't have any open PRs, but there's a lot of incomplete things
<jmercouris>
and without an update in many many months, I am inclined to believe those things will not be completed
<sjl>
I mean, isn't the solution to that to send PRs?
<sjl>
in the CL world I treat anything that's had commits in the past couple of years as "still active"
<jmercouris>
Yes, that would be a good solution
<jmercouris>
maybe I should submit some PRs
<sjl>
Most CL things don't tend to break every month or two like in some other languages
<sjl>
So if something doesn't have activity for a year or two, it's fine
<sjl>
but yeah, if it's missing stuff you want, the first thing to do would be to PR the original repo
<sjl>
If it turns out that the author doesn't want to maintain it anymore, okay, fork it to an orphanage org (ideally with their blessing)
<sjl>
but you'd need to write the code for the PR anyway, so it doesn't hurt to send it
<jmercouris>
sjl: Yeah, you are correct
<jmercouris>
sjl: What do you think, do you prefer Xach's "guild" approach to a code orphanage, or do you think it should be a larger, growing organization that shares responsibility?
<jmercouris>
I guess one of the issues with github is there doesn't appear to be some sort of democratic pull request review (as far as I can tell) in which a group of people agreeing on consensus could merge changes, this makes it necessary to find "expert, trusted" reviewers
<jack_rabbit>
jmercouris, I think there are add-ons or plug-ins to do that.
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<sjl>
I generally prefer finding a particular person who's interested in a project and passing maintainership off to them
<jmercouris>
sjl: These "project" leaders could emerge in what is part of a project organizations
red-dot has joined #lisp
<sjl>
having a team of people means no one person owns anything, and there's always an air of "someone else will get around to reviewing it"
<jmercouris>
I think naturally individuals withn an organization will adopt sections of the "codebase" and take ownership
<jmercouris>
but in this case, the unit of granularity would be a "repository" within a group of repositories
<jmercouris>
jack_rabbit: Do you know the names of any?
sellout` has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
<jmercouris>
sjl: After reviewing one or two PRs for a particular repository, I think a user will feel a sense of ownership towards that repository, while at the same time having a group of other individuals to support them
<sjl>
hopefully
<jmercouris>
Plus if there is anything I know about Lisp users, I know they will not hesitate to tell you when they think you are wrong, so maybe the group review thing could work quite well anyway :P
<jack_rabbit>
I do not, but I've seen features like that.
<jmercouris>
Using this API here: https://developer.github.com/v3/pulls/reviews/ I could program somethig that says something like "when there is 75% agreeance on merging a PR, and min 3 users, allow a merge" or something like that, thoughts?
josemanuel has quit [Client Quit]
papachan has quit [Quit: WeeChat 2.0]
fourier has joined #lisp
parjanya has joined #lisp
Tobbi has joined #lisp
smurfrobot has joined #lisp
dino has joined #lisp
dino is now known as Guest92705
KarlDscc has quit [Remote host closed the connection]
<Xach>
jmercouris: To be frank, I think you are cuckoo and your ideas won't work out. But I also felt that way about drmeister when he started making a new CL, and that is proving me wrong for a long time now. So I guess I am more inclined to wait and see and cheer if things work out.
<Xach>
I admire people with ideas who do work
<Xach>
I also thought slime would be a bust. What do I know?
smurfrobot has quit [Ping timeout: 260 seconds]
<jmercouris>
Xach: Perhaps I am a little crazy, :P
<phoe>
jmercouris: good luck!
<jmercouris>
A lot of people already told me that nobody would use my browser, but I discovered somebody with a dot-file for my browser! So at there's at least one person using it :D
asarch has joined #lisp
<jmercouris>
phoe: I haven't embarked on this journey quite yet, I am still thinking about it, but thank you nonetheless
<phoe>
Xach: a single person cannot feasibly maintain a central package repository for years with some degree of stability, you are completely bonkers
<jmercouris>
On one hand, I wish for a bigger Lisp community, on the other I like how it seems to be restricted mostly to experts, I don't wish for eternal september
<jmercouris>
However "small" the Lisp community is, I think there are enough members to maintain a core set of useful packages as part of an organization
<jmercouris>
and to pick up orphaned packages as well
kenanb has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
sjl has quit [Ping timeout: 240 seconds]
<fourier>
I guess at the end of the day most used packages are maintained by the same group of lisp enthusiast who know each other for years (via internet of course)
tom34 has joined #lisp
<fourier>
also there were a couple of community-sharing-etc projects, last one I can remember was cl ultraspec
sunwukong has quit [Ping timeout: 272 seconds]
Jesin has quit [Quit: Leaving]
tom34 has quit [Ping timeout: 240 seconds]
igemnace has quit [Quit: WeeChat 2.0]
fourier has quit [Ping timeout: 248 seconds]
tom34 has joined #lisp
JuanDaugherty has joined #lisp
nirved has quit [Quit: Leaving]
tom34 has quit [Ping timeout: 256 seconds]
Bike has quit [Ping timeout: 260 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
sjl has joined #lisp
red-dot has joined #lisp
tom34 has joined #lisp
LiamH has quit [Quit: Leaving.]
<tom34>
is 'practical common lisp' a good book to learn from?
<Shinmera>
yes
<tom34>
alright, cool
quazimodo has quit [Ping timeout: 265 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pedh has joined #lisp
damke has joined #lisp
pedh has quit [Ping timeout: 272 seconds]
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Achylles has quit [Remote host closed the connection]
jmercouris has quit [Remote host closed the connection]
Kaisyu has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
wxie has joined #lisp
drewc has joined #lisp
wxie has quit [Remote host closed the connection]
<sjl>
Is there any standard way to peek at a binary stream in CL? There's peek-char and unread-char for character streams, but I can't find anything for binary streams
tom34 has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 272 seconds]
<pjb>
There is not. You can always read a byte and keep it around.
<pjb>
have a look at com.informatimago.common-lisp.cesarum.peek-stream