smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
palmtree has joined #lisp
smurfrobot has quit [Ping timeout: 252 seconds]
smurfrobot has joined #lisp
GlaxyFish has joined #lisp
jmercouris has joined #lisp
GlaxyFish has left #lisp ["Closing Window"]
fikka has joined #lisp
palmtree has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
MichaelRaskin has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
kmurphy4 has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
varjag has joined #lisp
Arcaelyx_ has joined #lisp
fikka has joined #lisp
shka has quit [Quit: Konversation terminated!]
pjb has quit [Remote host closed the connection]
Arcaelyx has quit [Ping timeout: 260 seconds]
pjb has joined #lisp
megalography has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 245 seconds]
thuffir2 has quit [Ping timeout: 245 seconds]
bbobb has quit [Read error: Connection reset by peer]
thuffir has joined #lisp
bbobb has joined #lisp
energizer has quit [Ping timeout: 268 seconds]
pjb has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
megalography has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<makomo>
say i have a CASE form and i want to run a bit of code before/after the CASE form, depending on whether any of the cases within the CASE was actually hit
<makomo>
s/was/were
<makomo>
i could do it by adding WHENs before/after the case and then checking for all of the symbols within the case, but this duplicates all of those symbols
<makomo>
so i made a macro that does it. how would you name this macro?
<makomo>
i named it `wrap-case` but i'm wondering if someone can come up with a better name
<ludston>
Alternatively, you could yield a non-null value from all of your cases and wrap it in an if or when expression
<ludston>
Non-nil, pardon.
<makomo>
ludston: that would only work for after-forms though, right?
<ludston>
Oh, I see what you mean
<makomo>
plus, it requires me to save that value then somewhere, which means the whole CASE needs to be wrapped within a LET, producing "ugly" indentation
<makomo>
if i opt for (setf) instead of returning, then i'm again duplicating code within the clauses
<ludston>
In that case, whether or not this is a better way to do this, I would have the case return a lambda and then wrap the clauses around that
<makomo>
another style/philosophy issue: where do you draw the line between "i'll just write a macro for it and introduce my own control structure" and "i should probably just let this bit of duplication be, it's not worth the reader's effort to decipher what i meant"
pierpal has joined #lisp
<shrdlu68>
In effect, you have 3 different CASEs.
<makomo>
yep, that's how i expanded it :-)
<ludston>
I'd probably call it, "case-with" or "case-using"
<makomo>
ludston: hmm how would the CASE return a lambda? i didn't get what you mean
<shrdlu68>
makomo: That just sounds wrong.
<makomo>
shrdlu68: why?
<makomo>
you want to run some common code, then special code for every clause, then again common code
_cosmonaut_ has joined #lisp
<shrdlu68>
It's too verbose, seems like a simpler and more elegant solution is possible.
<makomo>
well, i did use a WHEN at first, but since there could be multiple symbols
<shrdlu68>
Why not do the check once?
<makomo>
i also thought about that, and that's an upcoming optimization, but isn't *that* important
* shrdlu68
squirms uncomfortably
<makomo>
haha :D
<ludston>
(let ((c (case "jobbo" ("jobbo" (lambda () (something)))))) (when c (setup) (funcall c) (cleanup)))
<makomo>
it's tricky because either one or both of the before/afters could be missing
<makomo>
so for example, you can't rely on the check being saved in the after body, if the before body never existed
<makomo>
in the after body, you can't rely on ...*
pierpal has quit [Ping timeout: 245 seconds]
<makomo>
in the after body, you can't rely on the check being saved/done already, if the tbefore body never existed**
<makomo>
ludston: oh hmm, that might be a good idea for a better (?) macroexpansion
<makomo>
inject (setup) and (cleanup) into the body of all of the clauses
<makomo>
that also gets rid of the lookup issue
<ludston>
makomo: I've found that if you have conditional behaviour, it's often better to delay executing that behaviour by passing it around in higher order functions, since then it is trivial to add logging later
<makomo>
mhm
<ludston>
makomo: Often, conditional behaviour is going to be triggered by some user-input, and the user will input data outside of the range that you predicted, so you will want to anticipate this
<ludston>
makomo: And by that I mean, anticipate that you will screw up your code, not "try and make sure that all of the inputs are santized"
<makomo>
i think i see what you mean. so you're referring to the process of actually writing the code, not the runtime behavior of the program
<shrdlu68>
(let ((which-case (case...)))...
pierpal has joined #lisp
<puchacz>
by the way, is there "case" with different test instead of default "eql"? or I would have to write a macro (or use one of the libraries)?
<loke>
puchacz: Yes.
ZombieChicken has quit [Quit: Have a nice day]
<puchacz>
loke: yes to what part?
smurfrobot has joined #lisp
<makomo>
probably the latter
<siraben`>
Just bought Practical Common Lisp :)
<loke>
puchacz: To your question. You asked if there is such a macro, or if you have to write it yourself. The answer to that question is “yes”.
<makomo>
i wrote my own string-case also, which uses STRING-EQUAL
<puchacz>
ok
<loke>
(OR it-exists need-to-write-it) ⇒ T
<siraben`>
What should I be wary about when following PCL?
<ludston>
loke: classic
<loke>
siraben`: The fact that it's old, so it doesn't mention Quicklisp.
pierpal has quit [Ping timeout: 245 seconds]
<siraben`>
loke: I see.
<loke>
siraben`: Also, I believe it mentions lispbox or some other similar package which are no longer devloped. You should be looking at Portacle.
<makomo>
siraben`: skip the part about "lispbox" in the beginning and use something like Portacle instead
<makomo>
yup :-)
<siraben`>
Fortunately I know how to use Emacs, so I'll find a way to customize my current configuration to work better with CL
markong has joined #lisp
<makomo>
then you're good to go
<siraben`>
Yay :)
<loke>
makomo: There is a STRING-CASE in Quicklisp which is likely much faster than what you'll be able to write.
<loke>
siraben`: There are two packages you need to learn: SLIME and Paredit.
<makomo>
loke: probably, i had no idea though. i expanded it into a COND which uses STRING-EQUAL lol
<makomo>
Smartparens!
<makomo>
loke: what kind of optimization could it do. hash the strings and compare the hashes perhaps?
<loke>
makomo: smartparens was less efficient last i looked. That said, it also seemed to be easier to learn, so perhaps it's a good idea for beginners.
<makomo>
i.e. hash them at compile-time and then just use a CASE with the hashes
<ludston>
Does anyone else use evil mode just for "da("?
smurfrobot has quit [Ping timeout: 252 seconds]
<makomo>
ludston: i just learned something :D. i use spacemacs's lisp-state for my sexp operations though
<makomo>
the keybinds aren't the shortest, `SPC k <something>` and then just `k <something>` once you're in the state
<loke>
makomo: it finds common prefixes and constructs a tree based on that. Then it compares multiple characters by OR-ing the differences and comparing to zero. It has hand-optimised assembly for SBCL so that it only does a comditional jump every four characters (if I remember correctly)
<makomo>
but i have to customize that
<makomo>
loke: oh dear
<loke>
makomo: There is a paper weitten on the algorithm ph Pkuhong.
<makomo>
ah, i think i know who that is
shrdlu68 has quit [Ping timeout: 260 seconds]
<makomo>
loke: all of the strings must be known ta compile-time right?
<loke>
makomo: Please do, because last I looked at it, changes in recent SBCL has reduced the performace of it. It's still faster than your typical macro, but the hand-optimised version of NUMERIC-CHAR= doesn't seem to be applied correctly, causing more conditional jumps than it used it.
<loke>
“than it used to”
shrdlu68 has joined #lisp
<makomo>
ah
<ludston>
That's pretty neat. I wonder if it could be generalised to deal with other lists, or even trees.
<loke>
I think it's because some of the internals that he was using have changed. If you can fix that, you'll be a hero :-)
aeth has quit [Read error: Connection reset by peer]
aeth has joined #lisp
<loke>
I think this STRING-CASE is a very good example of where Lisp shines.
<ludston>
It's a bit complex. I wonder how close the output is to something like (case (aref input 0) (#\f (when (eq (aref input 1) #o) (case (aref input 2) (insert rest of tree here)))))
shrdlu68 has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
<makomo>
loke: i doubt it, but one can dream :-)
<makomo>
loke: yeah, this is an excellent example IMO
<makomo>
beautiful
orivej has quit [Ping timeout: 252 seconds]
<ludston>
Oh you can see the macro output just aboe the assembler output. I can answer my own question. Yes it is pretty much identical to that, but for some reason he's gone with numeric-char= instead of doing a lookup
shrdlu68 has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
<ludston>
Because he thinks that doing 6 separate char= comparisons is going to be faster than #'equal?
<ludston>
I don't understand lol. Why be like, "I know how to compare strings faster than the people writing the compiler"?
smurfrobot has quit [Remote host closed the connection]
ludston has quit [Remote host closed the connection]
<jmercouris>
the thing I don't understand is this sentence: "db in a package myapp.db is a function for connecting to each databases configured the above."
smurfrobot has joined #lisp
<jmercouris>
and then it shows the following snippet below: "(use-package '(:myapp.db :sxql :datafly))"
JuanDaugherty has joined #lisp
<jmercouris>
but, if I look in my skeleton project, I find no function named "db"
<jmercouris>
I just answered my own question, nvm everyone
<jmercouris>
seems the function does exist, just wasn't being picked up by company, had to look for it in the source
<jmercouris>
lesson learned- don't trust company
smurfrobot has quit [Ping timeout: 245 seconds]
EvW1 has joined #lisp
<jmercouris>
so, I have an environment variable that I would like to set for uiop:getenv
pierpal has joined #lisp
<jmercouris>
I am launching my program via slime
<jmercouris>
how can I set this environment variable in this case?
pierpal has quit [Client Quit]
pierpal has joined #lisp
EvW1 has quit [Ping timeout: 260 seconds]
eli_oat has joined #lisp
palmtree has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
smurfrobot has joined #lisp
eli_oat has quit [Client Quit]
kajo has quit [Ping timeout: 245 seconds]
kajo has joined #lisp
sbryant has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Ping timeout: 252 seconds]
matijja has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 260 seconds]
thuffir has quit [Ping timeout: 245 seconds]
sbryant has joined #lisp
wildbartty has quit [Remote host closed the connection]
<shrdlu68>
jmercouris: "Launching it via slime"?
<jmercouris>
shrdlu68: Well, I'm in a slime repl, and then calling the function to launch my application
ebrasca has joined #lisp
<shrdlu68>
As far as I know, the application shares the same env as slime.
ebrasca has quit [Remote host closed the connection]
<jmercouris>
when I say env, I mean environment variables, like `set --export some-var some-value` in a normal shell
<jmercouris>
which is what uiop:getenv is doing
<shrdlu68>
Me too.
<jmercouris>
the problem with this is that I am within emacs
thuffir has joined #lisp
ebrasca has joined #lisp
<jmercouris>
so I can't just set some environment variable in my .bashrc .profile or whatever
<jmercouris>
I am launching a standalone GUI emacs
<jmercouris>
that would be fine if I had launched emacs -nw in a terminal
<shrdlu68>
I don't think you share the same env as emacs, since your implementation is exec'd.
<jmercouris>
what do you mean by that?
<shrdlu68>
One way would be to launch your implementation with the variables, like "FOO=BAR /usr/bin/sbcl"
<jmercouris>
I would like to start my application within slime though
<jmercouris>
within my already running repl
matijja has joined #lisp
<jmercouris>
I could hard-code/override the environment lookup, but that doesn't seem right
<shrdlu68>
I don't think it's possible to "inject" environmental variables, except by manipulating the data structure that holds the environmental variables.
<shrdlu68>
Which is implementation-specific.
<jmercouris>
it's not about injecting environmental varialbes
<jmercouris>
s/varialbes/variables
<jmercouris>
it's about setting them within a context
<jmercouris>
at any rate, it seems impossible
tomsen has joined #lisp
beach` has joined #lisp
kmurphy4 has quit [Quit: kmurphy4]
orivej has quit [Ping timeout: 260 seconds]
quazimodo has quit [Ping timeout: 260 seconds]
beach has quit [Ping timeout: 245 seconds]
<shrdlu68>
jmercouris: I'm curious - why use environmental variables?
<jmercouris>
It's not my choice
<jmercouris>
it is part of envy, which is part of caveman
<jmercouris>
I would have used a plist file or something
<jmercouris>
interesting, seems there is a way to set it manually, looking at it again
palmtree has joined #lisp
<jmercouris>
he uses osciat within the repl
<jmercouris>
never thought about that
palmtree has quit [Client Quit]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
m00natic has joined #lisp
thuffir has quit [Read error: Connection reset by peer]
schjetne has quit [Ping timeout: 265 seconds]
schjetne has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
thuffir has joined #lisp
schjetne has quit [Ping timeout: 245 seconds]
shrdlu68 has quit [Ping timeout: 245 seconds]
pjb has joined #lisp
shrdlu68 has joined #lisp
jason_m has joined #lisp
vaporatorius__ has joined #lisp
vap1 has quit [Ping timeout: 240 seconds]
shrdlu68 has quit [Ping timeout: 252 seconds]
shrdlu68 has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
DonVlad has joined #lisp
fikka has joined #lisp
tomsen has quit [Ping timeout: 252 seconds]
thuffir has quit [Ping timeout: 245 seconds]
m00natic` has joined #lisp
schjetne has joined #lisp
m00natic has quit [Ping timeout: 260 seconds]
matijja has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 264 seconds]
shrdlu68 has quit [Ping timeout: 245 seconds]
shrdlu68 has joined #lisp
matijja has joined #lisp
thuffir has joined #lisp
shrdlu68 has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
shrdlu68 has quit [Ping timeout: 252 seconds]
shrdlu68 has joined #lisp
<dim>
Xach: hi! do you know off-hand how to implement streaming uploads with zs3? by that I mean that you only ever have a small part of the content to upload in the client's memory...
oleo has quit [Quit: Leaving]
schjetne has quit [Ping timeout: 245 seconds]
FreeBirdLjj has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
oleo has joined #lisp
FreeBirdLjj has quit [Ping timeout: 252 seconds]
Negdayen has joined #lisp
pierpal has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
<Xach>
dim: Hmm, I don't know, sorry. I'd have to look at what drakma provides and how zs3 uses it.
<Xach>
dim: i know there are chunking upload APIs that could be used regardless of what drakma provides, but i also know that is not in ZS3 right now.
<dim>
I don't think I can use drakma level facilities here, the whole point is that I don't know the size of the content I am uploading until the end, because I am already receiving the content in a streaming fashion
fikka has joined #lisp
<dim>
I could always use my already existing batch facility and create multiple S3 files, one per batch, and manually consider them as a multiple upload thing, though
<Xach>
dim: Interesting. I haven't thought about how S3 supports incoming objects of unknown size.
<Xach>
I don't think drakma would inherently have a problem with it, but I haven't checked.
SenasOzys has joined #lisp
<dim>
apparently you can upload up to 10_000 chunks of 5MB content, and the last chunk “closes” the multi-part upload, and it can even be done in parallel
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
shrdlu68 has quit [Remote host closed the connection]
<dim>
my use case is (of course) pgloader related: a customer needs support for AWS Redshift as a target; and I just discovered that Redshift (a fork of PostgreSQL 8.0) doesn't have the COPY FROM STDIN feature, instead you need to COPY FROM S3://, basically
shrdlu68 has joined #lisp
<dim>
so I'm going to do MySQL | S3 | Redshift, all in streaming, and without having to load the full contents of a MySQL table in pgloader memory if I can avoid it, of course
beach` is now known as beach
<Xach>
dang!
michel has quit [Remote host closed the connection]
michel has joined #lisp
Bike has joined #lisp
<dim>
well it's a SMOP as they say, and if using the S3 multipart upload protocol isn't possible with current zs3, I think it's going to be easier for me to do something that looks like it with plenty of "small" objects that are manually managed in pgloader, I don't actually need any other tool to see that as a single file per source table anyway, and also I will be able to have more concurrent processing
<dim>
thanks for your answer, I think I know what code to write now ;-)
pierpal has quit [Ping timeout: 260 seconds]
shrdlu68 has quit [Ping timeout: 245 seconds]
shrdlu68 has joined #lisp
michel has quit [Ping timeout: 245 seconds]
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
fraya has joined #lisp
jason_m has quit [Ping timeout: 260 seconds]
shrdlu68 has quit [Ping timeout: 245 seconds]
shrdlu68 has joined #lisp
thuffir has quit [Ping timeout: 245 seconds]
pierpal has joined #lisp
lumm has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
pierpal has quit [Ping timeout: 260 seconds]
thuffir has joined #lisp
warweasle has joined #lisp
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
pierpal has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
schjetne has joined #lisp
ludston has joined #lisp
thuffir has quit [Ping timeout: 245 seconds]
pierpal has quit [Read error: Connection reset by peer]
thuffir has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
thuffir has quit [Ping timeout: 260 seconds]
shka has joined #lisp
<shka>
hello
<shka>
i need opinion
<shka>
how would you react for (defun bhattacharyya (a b) ...)
<pjb>
I'd reach for my sanskit dictionary ?
<shka>
well, that is distance
<shka>
used to compare distributions
<pjb>
distance functions are good.
<shka>
and that's how it is called
pierpal has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
<shka>
but i don't know if i should put full name in code
<shka>
becaues it is slightly long
<pjb>
Yes, full name is better.
<shrdlu68>
pjb: Sanskrit?
<shka>
oh, so you are fine with it?
thuffir has joined #lisp
<shka>
shrdlu68: guy was from India
<pjb>
Full name is better than abbreviation, because full names can be found in dictionaries.
<shrdlu68>
Oh yeah, it's sanskrit, not sanskit.
<pjb>
just google for dist and for distance and see what I mean.
<shka>
yes, that's why i prefer full names as well
<pjb>
Yes, I meant +r
<MichaelRaskin>
Maybe it should be called bhattacharyya-statistical-distance?
milanj has joined #lisp
<shka>
pjb: thanks, i think i will stick to full name
<MichaelRaskin>
(question mark not part of the name)
<shka>
MichaelRaskin: bhattacharyya-distance is enough
<pjb>
google for bhattacharyya and you find it directly. Google for bhat, bhat-dist, anything and you're lost.
<pjb>
shka: so indeed, you could even name it bhattacharyya-distance since bhattacharyya is a proper name actually.
<shka>
cool
<shrdlu68>
As long as we stick to "Hamming distance" and "Levenshtein distance"...
<pjb>
exactly.
<shka>
well, I am fun with that
<shka>
*fine
<shka>
it is just bhattacharyya is rather complex string
<shka>
but if you are using slime, it matters not
<MichaelRaskin>
shrdlu68: those who try to cut distance out of Hamming distance will be punished by coding FFT with Hamming window
<pjb>
Not for everybody. Latin-derived language speaker will find it easy to type.
<pjb>
The syllabic structure is simple.
<shka>
i guess...
jmercouris has quit [Ping timeout: 260 seconds]
<shka>
anyway, thanks, we think pretty much alike
pierpal has quit [Read error: Connection reset by peer]
<pjb>
Modern editors and IDEs have a lookup function that will search in dictionaries, wikipedia, google the current selection (or symbol-at-point).
<MichaelRaskin>
Without even requiring any user interaction to start the search!
pierpal has joined #lisp
sjl__ has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
Firedancer has quit [Ping timeout: 248 seconds]
foom has joined #lisp
light2yellow has joined #lisp
sjl has quit [Quit: WeeChat 2.1]
fikka has quit [Ping timeout: 245 seconds]
gabiruh has quit [Quit: ZNC - 1.6.0 - http://znc.in]
SenasOzys has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
SenasOzys has joined #lisp
pierpal has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
__Myst__ has joined #lisp
f1gurehead has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
f1gurehead has quit [Remote host closed the connection]
pierpal has joined #lisp
remote has joined #lisp
remote has left #lisp [#lisp]
stardiviner has quit [Quit: WeeChat 2.1]
fikka has joined #lisp
SenasOzys has quit [Ping timeout: 260 seconds]
SenasOzys has joined #lisp
BitPuffin has joined #lisp
pierpal has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
flamebeard has quit []
dddddd has joined #lisp
smurfrobot has quit [Remote host closed the connection]
matijja has quit [Ping timeout: 245 seconds]
pierpal has quit [Ping timeout: 245 seconds]
quazimodo has joined #lisp
pierpal has joined #lisp
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
EvW has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
FreeBirdLjj has joined #lisp
__Myst__ has left #lisp ["WeeChat 2.1"]
Cymew has quit [Ping timeout: 252 seconds]
Cymew has joined #lisp
rippa has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
Cymew has joined #lisp
mindCrime has joined #lisp
<makomo>
do you guys think there will ever be an effort to create a new/revised CL standard? how realistic is that?
Cymew has quit [Ping timeout: 252 seconds]
<shka>
makomo: there will be no new official standard
<Bike>
there are several efforts. it's pretty unlikely they'll be at the level of an ANSI standard, though.
<makomo>
how can you know for certain?
pierpal has quit [Quit: Poof]
<shka>
makomo: not enough money
<makomo>
Bike: oh, i didn't know. like?
pierpal has joined #lisp
Cymew has joined #lisp
<beach>
makomo: Like WSCL.
<makomo>
beach: oh, i hadn't thought/forgot that WSCL fits that purpose. so WSCL is definitely not "just another Lisp implementation"?
<beach>
makomo: You are thinking of SICL. That's just another implementation.
<makomo>
beach: what are the most important things that will be added to WSCL?
<makomo>
or are planned to be added
<beach>
No functionality will be added, or very very little.
Cymew has quit [Ping timeout: 260 seconds]
<shka>
makomo: it is a cleanup project
<beach>
Maybe package-local nicknames.
<dim>
things like bordeaux-threads and sockets maybe?
<makomo>
oh i see, and stuff like threads and sockets?
<makomo>
what dim said
<makomo>
that's out of scope?
fikka has joined #lisp
<dim>
maybe even a run-program facility as in uiop, and something to access the environment variables... basically I was pretty happy about what https://libcork.io provides for C, and including that scope into a CL “standard” of sorts strikes me as a good idea…
<sjl>
Would a new CL that included all the commonly-used things (bt, usocket, gray streams, etc) be a Common Common Lisp?
<dim>
(of course half of libcork, or maybe more, are already part of CL)
beach` has joined #lisp
<dim>
sjl: Third Millenium Common Lisp? (there's already a 21st century attempt after all)
beach has quit [Disconnected by services]
beach` is now known as beach
<sjl>
Common² Lisp, asciified as C2L similar to I²C->I2C
pierpal has quit [Ping timeout: 252 seconds]
<makomo>
are there any other efforts besides WSCL?
Cymew has joined #lisp
<dim>
sjl: then we would have C2L and CLTL2...
<dim>
maybe WSCL is just the right name ;-)
<sjl>
dim: and clearly we'd need a C2LTL (and possibly a C2LTL2!)
Cymew has quit [Ping timeout: 245 seconds]
<MichaelRaskin>
CTLTL2TL
<MichaelRaskin>
Oops
<MichaelRaskin>
CLTL2TL
Cymew has joined #lisp
defunkydrummer has joined #lisp
hhdave has joined #lisp
smurfrobot has joined #lisp
m00natic` has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
vtomole has joined #lisp
siraben` has quit [Ping timeout: 260 seconds]
shrdlu68 has left #lisp [#lisp]
m00natic has joined #lisp
nowhere_man has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
manumanumanu has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
vtomole has quit [Ping timeout: 260 seconds]
playful-owl has quit [Quit: leaving]
Cymew has quit [Ping timeout: 245 seconds]
<sjl>
is it possible that every combination of c/2/t/l is meaningful, much like the c(ad)+r family?
mejja has joined #lisp
pierpal has joined #lisp
EvW has quit [Ping timeout: 245 seconds]
pierpal has quit [Client Quit]
makomo has quit [Ping timeout: 245 seconds]
pierpal has joined #lisp
elfmacs has quit [Ping timeout: 245 seconds]
surya has joined #lisp
milanj_ has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
milanj has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
_cosmonaut_ has quit [Ping timeout: 252 seconds]
mrcom has quit [Ping timeout: 276 seconds]
makomo has joined #lisp
surya has quit [Ping timeout: 260 seconds]
cgay has joined #lisp
mrcom has joined #lisp
MasouDa has joined #lisp
cage_ has joined #lisp
kmurphy4 has joined #lisp
<Xach>
it is not possible.
igemnace has joined #lisp
vtomole has joined #lisp
jfrancis has quit [Ping timeout: 256 seconds]
DonVlad has quit [Remote host closed the connection]
DonVlad has joined #lisp
nowhere_man has quit [Ping timeout: 260 seconds]
<defunkydrummer>
sjr: in truth today we are at ctlt3 level: most implementations implement cltl2 and a lot of extras that are almost portable thanks to portability libs. I don't think the state of the language is a problem at all.
DataLinkDroid3 has joined #lisp
DataLinkDroid2 has quit [Ping timeout: 240 seconds]
DonVlad has quit [Ping timeout: 260 seconds]
sz0 has joined #lisp
thuffir has quit [Ping timeout: 245 seconds]
mflem has joined #lisp
varjag has quit [Ping timeout: 245 seconds]
thuffir has joined #lisp
<defunkydrummer>
sjl: sorry, i wrote "sjr"
<sjl>
ah, I do ping on slj, but sjr is a typo I haven't added to my ping list :)
zachk has joined #lisp
hhdave has quit [Ping timeout: 252 seconds]
zachk has quit [Changing host]
zachk has joined #lisp
<phoe>
there's a de facto standard that all modern implementations comply to; it's implemented by c2mop, usocket, bordeaux-threads, lparallel, trivial-gray-streams, trivial-garbage, ASDF, UIOP et cetera
<katco[m]>
i'd like a solid standardized way of doing continuations
<oleo>
inhale, exhale, inhale.....
<oleo>
lol
<katco[m]>
uh oh... people have strong opinions about this?
<vtomole>
How would that work? Is it "If your implementation implements the standard, you can pretty much add anything else you want to it"?
smasta has joined #lisp
thuffir has quit [Ping timeout: 245 seconds]
thuffir has joined #lisp
katco has joined #lisp
<Bike>
that's how the standard already works
<Bike>
as long as the extensions follow certain limits, like not putting extra symbols in the CL package
<warweasle>
Luckily, the CL spec uses every possible combination of letters and numbers.
m00natic has quit [Remote host closed the connection]
<aeth>
Well, it's finite, isn't it? A symbol is produced from a string so the maximum length is probably array-total-size-limit. In SBCL, that's 4611686018427387901, which is probably the maximum possible in 64-bit systems
<aeth>
Or close to it. most-positve-fixnum is 4611686018427387903 in SBCL and SBCL uses (signed-byte 63)
thuffir has quit [Read error: Connection reset by peer]
<aeth>
If you wanted to define all of them, though, the real problem is char-code-limit, which is a lot less straightforward.
smurfrobot has joined #lisp
cgay has quit [Quit: leaving]
dxtr has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
cgay has joined #lisp
<warweasle>
aeth: I actually like the kitchen sink approach. I usually have to include a ton of libraries to get anything done in other langauges. With lisp, it's just there.
jeosol has joined #lisp
thuffir has joined #lisp
DonVlad has joined #lisp
nowhere_man has joined #lisp
DonVlad has quit [Ping timeout: 245 seconds]
energizer has joined #lisp
thuffir has quit [Ping timeout: 260 seconds]
lumm has quit [Quit: lumm]
<katco>
me too
lumm has joined #lisp
MasouDa_ has joined #lisp
MasouDa has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
xaxaac has joined #lisp
fikka has joined #lisp
Ven`` has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
thuffir has joined #lisp
Cymew has joined #lisp
Ven` has joined #lisp
Ven`` has quit [Read error: Connection reset by peer]
nowhere_man has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 240 seconds]
kmurphy4 has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
isBEKaml has joined #lisp
johnvonneumann has joined #lisp
johnvonneumann is now known as Guest95308
iqubic has joined #lisp
thuffir has quit [Ping timeout: 245 seconds]
Cymew has quit [Ping timeout: 245 seconds]
DonVlad has joined #lisp
Cymew has joined #lisp
epony has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
DonVlad has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
<phoe>
warweasle: kinda disagreeing with you on that point
<phoe>
pulling a system on Quicklisp tends to also pull multiple tens of its dependencies
DataLinkDroid4 has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
DataLinkDroid3 has quit [Ping timeout: 240 seconds]
SenasOzys has quit [Ping timeout: 245 seconds]
dieggsy has joined #lisp
jfrancis has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
Bocaneri has quit [Read error: Connection reset by peer]
jmercouris has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 252 seconds]
ym has quit [Quit: Leaving]
pierpal has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
dyelar has quit [Remote host closed the connection]
comborico1611 has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
igemnace has quit [Quit: WeeChat 2.1]
milanj_ has quit [Quit: This computer has gone to sleep]
pierpal has joined #lisp
Cymew has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
vtomole_ has joined #lisp
fikka has joined #lisp
vtomole has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 245 seconds]
<comborico1611>
What is predicate function like SYMBOLP but returns false for "symbolp ()"
<oleo>
??
<oleo>
nil is both a list and an atom
Cymew has joined #lisp
<Bike>
there is no such function built in. nil is a symbol.
<comborico1611>
Bike: I see. Thank you.
<oleo>
yah
fikka has quit [Ping timeout: 260 seconds]
papachan has joined #lisp
DemolitionMan has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
jmercouris has quit [Ping timeout: 245 seconds]
<phoe>
comborico1611: (and thing (symbolp thing))
<phoe>
or more verbosely (and (symbolp thing) (not (null thing)))
Cymew has joined #lisp
defunkydrummer has quit [Ping timeout: 245 seconds]
<comborico1611>
phoe: I was just trying to figure this out. Thanks! I needed the verbose to understand.
<phoe>
you want something that is a symbol AND that is not null
<comborico1611>
Ahh, yes. Very good.
lumm has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 245 seconds]
<aeth>
Depending on what you're doing you could also use types. e.g. (let ((x 'foo)) (check-type x (and symbol (not null))) x)
<aeth>
That would be if you wanted a correctable-at-runtime error if it's not a non-nil symbol
<comborico1611>
aeth: Seems too advanced for me, or my brain is tired.
<stylewarning>
(let ((tbl (make-hash-table))) (do-all-symbols (x tbl) (when x (setf (gethash x tbl) t))))
<comborico1611>
Hahah
fikka has quit [Ping timeout: 245 seconds]
slyrus1 has joined #lisp
<comborico1611>
phoe: Too much Perl lately.
<comborico1611>
Actually, I'm experimenting with sigils inside of Lisp.
<phoe>
comborico1611: please don't
<phoe>
or rather, sure thing you can, just don't tell other lispers to view your code
Cymew has quit [Ping timeout: 252 seconds]
<comborico1611>
Yeah, I know.
Cymew has joined #lisp
<aeth>
stylewarning: now we just need a way to not have to regenerate the hash table each time the function is called (what if someone adds a symbol?)
SenasOzys has joined #lisp
milanj_ has joined #lisp
fikka has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
bigfondue has joined #lisp
Cymew has joined #lisp
josemanuel has joined #lisp
SenasOzys has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
nika_ has quit [Quit: Leaving...]
varjag has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
sjl__ has joined #lisp
Cymew has joined #lisp
cage_ has quit [Read error: Connection reset by peer]
sjl has quit [Ping timeout: 245 seconds]
eli_oat has joined #lisp
orivej has joined #lisp
cage_ has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
thuffir has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
pierpal has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
<phoe>
wait a second
<phoe>
comborico1611: what are you trying to do?
pierpal has joined #lisp
Cymew has joined #lisp
<potatonomicon>
is there a way to make sbcl yell at me if it can't do tail recursion optimization? or does it do this by default and I just haven't seen it?
thuffir has quit [Ping timeout: 252 seconds]
<aeth>
If it's just SBCL you could parse disassemble (keep in mind that the case of its output depends on the value of *print-case*)
epony has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<potatonomicon>
don't really want to manually check the asm, since I will have a lot of functions that need this
Cymew has quit [Ping timeout: 245 seconds]
<cgay>
You could test your function with something that would cause extremely deep recursion. :)
<Bike>
potatonomicon: if you pump up SPEED optimization it might print notes
<Bike>
or maybe space
<potatonomicon>
alternatively, can I set the stack size larger?
<aeth>
potatonomicon: well if it's tail on itself you'd just have to look for something like this: ; 9A: B8B84C5120 MOV EAX, #x20514CB8 ; #<FDEFN FOO>
shwouchk has quit [Quit: Connection closed for inactivity]
Cymew has joined #lisp
<aeth>
That's present in this unless I (declare (optimize (speed 3))) in the function: (defun foo (x) (unless (<= x 0) (foo (1- x))))
phadthai has quit [Read error: Connection reset by peer]
sjl__ is now known as sjl
<aeth>
so you'd just look for a line with FOO or foo
<aeth>
(it will be foo if *print-case* is :downcase)
<phoe>
potatonomicon: note that the CL standard does not promise you that your code will be tail-optimized. An implementation may decide not to do TCO for any reason, such as (declaim (optimize (debug 3))).
<phoe>
And that is surprisingly common on developer machines.
<potatonomicon>
thats why I asked specifically for sbcl
<phoe>
Okiedokie. Just keep in mind that your code might blow stacks if you ever use tail calls in CL in places that might be called thousands+ of times.
<eschulte_>
Does anyone know of a way to read a lisp source file to a mix of S-exprs and say strings which would include enough information to rebuild the original source (including whitespace and comments)?
fikka has quit [Ping timeout: 245 seconds]
<potatonomicon>
yeah I will probably just redesign things a bit to not use it that much
<jmercouris>
not sure what to put after :references
Cymew has joined #lisp
<jmercouris>
also, references is not an accepted key
pierpal has quit [Read error: Connection reset by peer]
vlatkoB has quit [Remote host closed the connection]
fikka has joined #lisp
nowhere_man has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
kmurphy4 has joined #lisp
Cymew has joined #lisp
MasouDa_ has joined #lisp
<jmercouris>
looking at the source, seems no way to create a column with a foreign key
<jmercouris>
keyword args are only: type not-null default auto-increment autoincrement unique primary-key
fikka has quit [Ping timeout: 260 seconds]
<jmercouris>
oh well
MasouDa has quit [Ping timeout: 245 seconds]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
daniman has joined #lisp
emaczen` has quit [Read error: Connection reset by peer]
xaxaac has quit [Quit: Leaving]
Cymew has quit [Ping timeout: 245 seconds]
shka_ has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
vtomole_ has quit [Ping timeout: 260 seconds]
thuffir has joined #lisp
BitPuffin has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
emaczen` has joined #lisp
fikka has joined #lisp
Cymew has joined #lisp
zachk has quit [Quit: Leaving]
eli_oat has quit [Remote host closed the connection]
mejja has quit [Quit: mejja]
Cymew has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 240 seconds]
RebelCoderRU has quit [Ping timeout: 252 seconds]
thuffir has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
fikka has quit [Ping timeout: 260 seconds]
DonVlad has quit []
Cymew has joined #lisp
jeosol has joined #lisp
<jeosol>
jmercouris?
Cymew has quit [Ping timeout: 260 seconds]
<jmercouris>
jeosol: yes?
<jeosol>
I was able to reach some of the Asian folks who started the dev of the CLML library
<jmercouris>
no way? that's awesome
<jeosol>
One of them said he is no longer associated with it, referred me to another dude, who said he does not know how to reach the maintainer
<jmercouris>
lol, well, it is some progress
<jeosol>
Oh, sorry,
<jmercouris>
even if it is a dead end, at least it is knowledge of it being a dead end
<jeosol>
It is seems it is round and round so far. But I may just pick it up and proceed as discussed
<jmercouris>
yeah, the plan B wasn't too bad
<jeosol>
I can pick it up, I just don't want to have issues with that maintainer who I can't reach so far
Cymew has joined #lisp
<jeosol>
Especially, since there are license issues involved
<jeosol>
plan B?
<jmercouris>
well, treating it as a dependency
<jmercouris>
and licensing new code built on top of it in a different way, freezing it
<jmercouris>
no need to bring things back upstream, basically what we discussed
<jeosol>
Oh I see.
<jmercouris>
or even just comitting to the same license... as unfavorable as it is
<jeosol>
Makes sense. That's one option. Freeze it
<jmercouris>
I guess since you will be the author, you may package and license it in different ways
<jeosol>
that was the plan, as long as they are willing to relax or work around it. One of the dudes said it was possible, but he is not longer involved
DonVlad has joined #lisp
<jmercouris>
I see
<jmercouris>
a clean room implementation may also be quite fun
<jmercouris>
it really depends on what you are going for, whether you want to actually get something done or not
<jmercouris>
or it is more about the fun of doing it
isBEKaml has left #lisp [#lisp]
Cymew has quit [Ping timeout: 245 seconds]
<jeosol>
I actually want to get something done. I have a huge code base in lisp, and have written small codes for KNN, fuzzy clustering, etc. For some other applications, I make calls to Python
<jeosol>
I would prefer things to be in lisp if at all possible.
fikka has joined #lisp
Cymew has joined #lisp
<jeosol>
From the look of the library, they seem to cover a lot of applications already and I would want to start by using it in purely application mode
<jmercouris>
jeosol: how do you ffi to python?
<jeosol>
run several open source examples using it.
<jeosol>
haha, no I am not ffi/cffi expert. It is just system call.
<jmercouris>
oh, I see
<jmercouris>
jeosol: have you published any of your existing code online?
<jeosol>
I wrote a python script that does everything writes a file. I do a system call to that script (via run-program ) and read the output file from the lisp side
<jmercouris>
so you're basically piping via the file system
<jmercouris>
seems pretty simple, lot less work than maintaining a server
<jmercouris>
I wish IPC in lisp was more straightforward, especially for unix domain sockets
<jeosol>
Oh, yeah. For my case, I wanted to use some specially tools in scikit-learn lib
<jeosol>
I am no socket expert, this is how I have done the interactions so far.
<jeosol>
btw, I sent out one last email to the Jap contact explicitly discussing the licensing issue and what I plan to do, and that he should direct me to who has the authority to make decisions.
<jmercouris>
the http socket support/libs are "ok", they are also not so good compared to other languages (from my perspective of learning them), but they are certainly much better than the unix domain socket support
<jmercouris>
s/http socket/bsd socket
Cymew has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 245 seconds]
nowhere_man has quit [Ping timeout: 260 seconds]
<jmercouris>
jeosol: I know you weren't trying to be offensive, but jfyi, in the US "Jap" is considered derogatory, mostly because of it's usage as slang during WW2
<jeosol>
I am sorry,
<jeosol>
It was not my intent at all.
<jeosol>
TIL sth
<jmercouris>
No, I gotcha, just pointing it out in case you ever meet a Japanese American :D
<jeosol>
Thanks for the info.
Cymew has joined #lisp
<jmercouris>
also sounds good, hopefully they'll reply back with some sort of acknowledgement or even a new license..
<jeosol>
To avoid future issues, I would like to pick the library up, clean up any issues and make it open for people to use and contribute
<jmercouris>
s/it's/its
<jmercouris>
yeah, otherwise, it is like many other efforts in lisp, fragemented into its own ecosystem
<jeosol>
yeah, I am trying to avoid that
<jmercouris>
that's something that I think may be a pattern, the nature of lisp, the nature of macros, the strong customizability means that people get stuck in their own little silos and ecosystems, they end up wanting to make their own exact libraries
<jeosol>
Which is why I said, we can have a small committee going forward regarding this
fikka has joined #lisp
<jmercouris>
Yeah, definitely
<jeosol>
I did try to run Gabor Meli's code in the past, but I didn't have GPU so the training of the NN was taking too many days.
<jeosol>
I will try to pick of up again, modify the code to run a small problem instance
<jeosol>
I did send him an email, but no response at all.
<jmercouris>
the problem space I am most interested in, is one what White_Flame was telling me about, genetic algorithms
<jmercouris>
I didn't know anything about them really until about a week ago, fascinating stuff, seems like a specialty for Lisp
Cymew has quit [Ping timeout: 245 seconds]
<jmercouris>
at least, for one particular type of genetic algorithm
<jmercouris>
jeosol: why no GPU? were you running it on a server?
Cymew has joined #lisp
<jeosol>
I have worked on genetic algorithms
<jmercouris>
jeosol: in lisp?
<jeosol>
and particle swarm optimization
<jeosol>
these are the two algorithms I have used mostly
<jeosol>
There is actually a code I am trying to clean up that looks into advanced forms of the GA
<jeosol>
jmercouris: for the GPU part, I mean, I took his problem, and ran it on my linux box. Gabor said with GPU (don't remember the spec) it took 1 day to train
<jeosol>
After my case took two days, I decide to kill it. It was not a dedicated server.
<jmercouris>
Oh, I see, so just your main machine just has onboard graphics or something
<jeosol>
Yeah, nothing fancy. I will go back to this blog again and look at the specs. But I should be able to run a small case
<jeosol>
which GA type are you interested in for which problem area?
Cymew has quit [Ping timeout: 240 seconds]
<jmercouris>
jeosol: I'm trying to develop an algorithm that optimizes the packing and shipping of boxes
<jmercouris>
I've thought about what kinds of things to mutate against, and a couple of things I thought would be good would be packing strategies
<jeosol>
Cool application.
Cymew has joined #lisp
<jmercouris>
of course the packing strategies will be functions, so to be able to mutate them with each other (as code), would be interesting, instead of just tweaking the args passed to some function
<jeosol>
Ok, you may also thinking about GP -- genetic programming, it is one form that can evolve strategies and new insights
<jmercouris>
actually yes, I am thinking of genetic programming
<jeosol>
That makes sense, it more applicable than the conventional GA
daniman has quit [Quit: WeeChat 2.0.1]
<jeosol>
and yes, lisp is more applicable, convenient facilities
<jmercouris>
I just read the wiki article, seems I was confusing the terms while reading
<jmercouris>
as you can see, my understanding is still very poor
<jeosol>
do you have any base code?
<jmercouris>
base code?
<jmercouris>
the code to evolve?
<jeosol>
I meant starting code to work it
<jmercouris>
No, not yet
<jmercouris>
I am writing survey software first, to determine if anyone actually would want this product
<jmercouris>
I'm almost done with my survey software
<jeosol>
I came to lisp the first time because of GA I was trying to convert to C++ at the time.
<jmercouris>
It's been a much harder task than I imagined it would be
<jeosol>
Nice, I think they would
<jeosol>
GP is not straightforward, encoding is the main issue
<jmercouris>
as with all of these silver bullets, it is a lot of "art" still
<jmercouris>
feature selection, how we normalize our data, etc
Cymew has quit [Ping timeout: 240 seconds]
<jmercouris>
people treat it like a crystal ball though...
<jeosol>
the solutions for GP problems are not always clear but when you see the results, you will have the aha moment, like yeah, that makes sense
<jmercouris>
Yeah, I have no illusions that it will just magically work, I just thought this might be an interesting way to iterate an algorithm
<jeosol>
Yes, the keys are the objective function and how the variables/features are parameterized
<jmercouris>
well, I didn't think of it, White_Flame did, after I described the problem
<jeosol>
Oh I see, he works in that space too?
<jmercouris>
not exactly
Cymew has joined #lisp
<jmercouris>
he is an expert in that space though
<jmercouris>
I'm not sure if he would like me to share what he does, you may ask him yourself
TCZ has joined #lisp
<jeosol>
No problem, I am just asking
<jeosol>
as in getting people with similar background for the ML lib work
<jmercouris>
Yeah, he might be interested
<jmercouris>
if I had to guess
<jeosol>
White_Flame?
<jeosol>
not sure he is still here
<jmercouris>
he is on at different hours every day
<jeosol>
anyway, we can discuss more if possible
<jeosol>
But it is very interesting problem
<jmercouris>
yeah, it is quite challenging
<jmercouris>
when I first started I thought "huh, can't be that hard"
<jmercouris>
but when I started trying to write an algorithm I realized the amount of permutations I would have to test
<jmercouris>
so I started thinking about greedy algorithms, and even those were way too heavy
<jeosol>
permutations?
Cymew has quit [Ping timeout: 252 seconds]
Cymew has joined #lisp
<jeosol>
I will have to get more info regarding your problem, otherwise, a straightforward GA may get you sth albeit limited and can be used to glean more insights
kmurphy4 has quit [Remote host closed the connection]
<jeosol>
will depending on how the solutions are encoded.
<jmercouris>
permutations, I mean combinations of ways one might stack boxes
<jeosol>
I wanted to see that you meant by permutations. For a greedy method, you will need to test many combinations.
EvW has quit [Ping timeout: 260 seconds]
Bike has quit [Ping timeout: 260 seconds]
<jmercouris>
yes, indeed
<jeosol>
they are global algorithms and you won't need to test many combinations. As long as each feature's limits are known, e.g., (bounds for continuous variables, number of possibilities for discrete values, ...) it's fine
<jmercouris>
yeah, of course, there is a maximum package size, things like tha
<jmercouris>
the complete domain space is this: what is the cheapest way to combine shipping products, and parcels to deliver them somewhere
<jmercouris>
e.g. if I have 3 parcels to ship, perhaps I should ship two of them grouped together with some USPS product, and the last one with some UPS product to ship it most cheaply somewhere
Cymew has quit [Ping timeout: 245 seconds]
<jeosol>
I see.
<jmercouris>
so I have to solve several problems,how to combine packages together, and how to combine products together
<jmercouris>
there is an explosion of permutations
<jmercouris>
furthermore, for many products, the prices are not discrete, but rather continuous
<jeosol>
hahaha. But the products are bounded, those are discrete or integer. prices can be encoded as continuous to say 2 decimal places (cents)
Cymew has joined #lisp
gigetoo has quit [Ping timeout: 260 seconds]
<jeosol>
The algorithm will figure out that combination and permutations, that is what it does.
<jmercouris>
yeah, that makes it a little bit better
<jmercouris>
anyways, coding something like that by hand, is unbelievably difficult
<jmercouris>
especially when the products and rules surrounding products are chaning all the time
gigetoo has joined #lisp
<jmercouris>
which is why I was thinking about some generalized solution that can be more easily adapted and understood
<jeosol>
I think you will have to solve the problem with fixed static inputs, and later make the interface general enough to actually run the GA runs in parallel given new instance values
<jmercouris>
what do you mean by "fixed static inputs"?
<jeosol>
in essence, you wrap the GA engine with something that feeds input as a stream
fyodost has joined #lisp
<jeosol>
What I mean is that for the GA to run effectively F(X) must not be stochastic for the same X (it can still perform well if things change though).
<jmercouris>
Ah, I see
Cymew has quit [Ping timeout: 245 seconds]
<jeosol>
so I mean, first ignore the fact that things are changing, then solve a fixed instance (products and prices), then generalize
<jmercouris>
yes, that was the plan actually
<jmercouris>
work with a very small, and artifical subset of rules
<jeosol>
You problem can be very fast, my F(X) takes 5 hours
<jmercouris>
and see if I can select some good genes/encodings, and then scale things up
<jeosol>
yeah, that is correct.
<jeosol>
So what you are maximizing or minimizing, shipping cost, travel times?
<jmercouris>
Shipping cost
<jeosol>
You said so before, my bad
<jmercouris>
though, depending on the results of my survey, maybe nobody cares about shipping cost
mindCrime has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
<jmercouris>
maybe they care about box inventory, how many boxes of what types they need to keep
<jmercouris>
I'm not really sure what people care about, so I'll collect data first
<jmercouris>
my survey software is so close to being done
EvW has joined #lisp
<jeosol>
cool, will be interested to see what the survey says, but the problem is actually multiobjective, then we are heading into the territory of pareto solutions,
<jeosol>
but a first step, focus on shipping cost, and worry about what the client may need.
<jmercouris>
yeah, it is also a way to actually collect interest/potential customers
<jeosol>
That's good actually. You are in the US right?
<jmercouris>
I am a dual EU/US citizen, I spend my time about half/half
<jeosol>
I think you will get customers ...
Cymew has quit [Ping timeout: 245 seconds]
<jeosol>
people ship things all the time
<jmercouris>
sure, but many questions remain
<jmercouris>
are they usually shipping one or two items?
<jmercouris>
if they are shipping more than one item, perhaps it is only large companies like amazon, in which case, their integration costs would be astronomical
<jmercouris>
anyways, these are business questions, and don't really belong on #lisp
<jeosol>
Amazon has the option to package items depending on user preference.
fikka has joined #lisp
<jeosol>
Not sure what scale you are looking at,
<jmercouris>
we can move to #lispcafe
Cymew has joined #lisp
<jeosol>
I was worried we are not discussing lisp specific stuff
<jeosol>
:-)
thuffir has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
Cymew has quit [Ping timeout: 260 seconds]
asarch has joined #lisp
Cymew has joined #lisp
TCZ has quit [Quit: Leaving]
karlosz has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
kajo has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
kajo has joined #lisp
Cymew has joined #lisp
bbobb has quit [Remote host closed the connection]
bbobb has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
dieggsy has quit [Ping timeout: 245 seconds]
Bike has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
markong has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
thuffir has quit [Ping timeout: 260 seconds]
markong has joined #lisp
phadthai has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
Cymew has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
thuffir has joined #lisp
DonVlad has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
fikka has joined #lisp
fraya has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 248 seconds]
thuffir has quit [Ping timeout: 252 seconds]
vaporatorius__ has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 260 seconds]
jmercouris has quit [Ping timeout: 245 seconds]
ludston has quit [Remote host closed the connection]
sjl has quit [Quit: WeeChat 2.0.1]
charh has joined #lisp
sjl has joined #lisp
Cymew has joined #lisp
jeosol has quit [Quit: Page closed]
fyodost has quit [Quit: Leaving]
Cymew has quit [Ping timeout: 245 seconds]
EvW has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
varjag has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
bbobb has quit [Quit: bbobb]
Cymew has quit [Ping timeout: 240 seconds]
umpc has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
papachan has quit [Ping timeout: 264 seconds]
sellout has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 245 seconds]
azrazalea has quit [Ping timeout: 256 seconds]
thuffir has joined #lisp
nowhere_man has joined #lisp
umpc has joined #lisp
Cymew has joined #lisp
alandipert has quit [Ping timeout: 256 seconds]
alandipert has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
epony has quit [Read error: Connection reset by peer]
epony has joined #lisp
Cymew has joined #lisp
azrazalea has joined #lisp
puchacz has quit [Remote host closed the connection]
puchacz has joined #lisp
<iqubic>
Looks like quantum computer programmers are turning to lisp.