<beach>
Clasp had one too, &va_rest or something like that.
<jackdaniel>
ecl otoh doesn't introduce any extras there
Th30n has quit [Ping timeout: 240 seconds]
mon_aaraj has quit [Ping timeout: 255 seconds]
mon_aaraj has joined #commonlisp
treflip has joined #commonlisp
lisp123 has joined #commonlisp
mon_aaraj has quit [Ping timeout: 246 seconds]
mon_aaraj has joined #commonlisp
rodicm has joined #commonlisp
random-nick has joined #commonlisp
rodicm has quit [Ping timeout: 276 seconds]
Th30n has joined #commonlisp
rodicm has joined #commonlisp
Th30n has quit [Ping timeout: 246 seconds]
yauhsien has joined #commonlisp
rodicm has quit [Ping timeout: 240 seconds]
yauhsien has quit [Ping timeout: 240 seconds]
tfb has joined #commonlisp
treflip has quit [Quit: Quit]
Cymew has quit [Ping timeout: 246 seconds]
<pjb>
Unfortunately, why the implementation may declare additionnal keywords, the standard doesn't provide a way to know their syntax: do they take 0, 1 or more parameters? Are they changing the parameter kind, or are they just qualifying a "normal" parameter"?
waleee has joined #commonlisp
<jackdaniel>
since they are implementation specific, then their purpose is also implementation specific, so there wouldn't be much benefit from knowing how many parameters they take programmatically (if you don't understand semantics of them)
<pjb>
(mandatory-1 &unboxed mandatory-2 &others like-rest &fast-key key-1 key-2 &and-some-more-p &and-this a b c)
<pjb>
jackdaniel: it prevents parsing lambda-lists with them conformingly.
rodicm has joined #commonlisp
<pjb>
jackdaniel: it's not a semantic question, it's a syntactic question. You want to be able to parse lambda-lists, to write macros correctly.
<pjb>
It's like code-walking.
azimut has joined #commonlisp
<jackdaniel>
pjb: if you don't understand the operator (or a lambda list keyword) semantics, then you may at most do moon-walking
<jackdaniel>
because it in theory may turn around any assumption you will bake into the moonwalker
<pjb>
you only need to know the syntax, to perform syntactic transformations!
<jackdaniel>
s/syntactic/galactic/
* jackdaniel
goes to a coffee break
<jackdaniel>
for*
Th30n has joined #commonlisp
mixotricha has quit [Ping timeout: 252 seconds]
<lisp123>
pjb: do you mean implementations don't specify the syntax of additional lambda list keywords?
Oddity has quit [Ping timeout: 246 seconds]
rodicm has quit [Ping timeout: 240 seconds]
tyson2 has joined #commonlisp
<pjb>
lisp123: yes. The standard only provides a way to let them declare the new lambda list keywords via the lambda-list-keywords constant variable.
<SR-71>
Can someone suggest a somewhat lispy solution to this problem?
<jeosol>
SR-71: Do you mean convert the code to CL?
lisp123 has quit [Read error: Connection reset by peer]
lisp123 has joined #commonlisp
lisp123 has quit [Read error: Connection reset by peer]
mon_aaraj has quit [Ping timeout: 276 seconds]
mon_aaraj has joined #commonlisp
<SR-71>
The solution provided is higelly proccedural.
<SR-71>
*highly
<SR-71>
I was wondering if we could produce some clever lisp solution
lisp123 has joined #commonlisp
rodicm has joined #commonlisp
mon_aaraj has quit [Ping timeout: 246 seconds]
<lisp123>
SR-71: Sounds like a task for our good friend, the lazy dragon
<lisp123>
(recursion)
mon_aaraj has joined #commonlisp
jmes has quit [Ping timeout: 276 seconds]
pseigo has quit [Quit: left]
pseigo has joined #commonlisp
pseigo has quit [Changing host]
pseigo has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
aartaka has joined #commonlisp
Lord_of_Life has quit [Excess Flood]
rodicm has quit [Ping timeout: 246 seconds]
Lord_of_Life has joined #commonlisp
<beach>
pjb: It is actually even worse. Some lambda-list keywords can appear anywhere in the list, and some can appear more than once, so the task of parsing the lambda list becomes very difficult indeed.
<pjb>
Indeed.
<pjb>
We'd have to find a way to specify all those syntactic constraints.
<beach>
I came up with an extensible parser; each implementation would add rules to the parser. Then, at least we could have a library that does most of the work in an implementation-independent way.
<pjb>
Sounds good.
<beach>
Otherwise, jackdaniel is right. We are doomed to have a parser for each implementation.
<beach>
Yes, but I am not happy with the result, so I am still thinking about this problem from time to time.
Cymew has joined #commonlisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai_ has joined #commonlisp
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #commonlisp
gxt_ has quit [Remote host closed the connection]
gxt_ has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
ahlk has quit [Ping timeout: 272 seconds]
<SR-71>
I there a clever translation for the following function in lisp?
<Josh_2>
I can't say I ever feel very comfortable using BKNR in commercial software
gxt_ has quit [Remote host closed the connection]
gxt_ has joined #commonlisp
lisp123 has joined #commonlisp
rodicm has quit [Ping timeout: 276 seconds]
lisp123 has quit [Ping timeout: 246 seconds]
<Josh_2>
I think in the future perhaps I will just use BKNR for a backup, although its probably easier to use cl-store to save transaction information to the disk/postgres
<pjb>
SR-71: in board games, it's advantageous to allocate cells on the border, so you don't have to clip the coordinates!
mariari has quit [Quit: WeeChat 3.5]
mariari has joined #commonlisp
gxt_ has quit [Remote host closed the connection]
gxt_ has joined #commonlisp
Brucio-61 has joined #commonlisp
ahlk has joined #commonlisp
orestarod has joined #commonlisp
rodicm has joined #commonlisp
Th30n has quit [Quit: WeeChat 3.5]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 240 seconds]
Bike has joined #commonlisp
pjb has quit [Read error: Connection reset by peer]
igemnace has quit [Remote host closed the connection]
mon_aaraj has quit [Ping timeout: 240 seconds]
treflip has joined #commonlisp
mon_aaraj has joined #commonlisp
z4kz has quit [Quit: WeeChat 3.5]
zak1 has joined #commonlisp
zak1 is now known as z4kz
pjb has joined #commonlisp
pseigo has quit [Quit: left]
Cymew has quit [Ping timeout: 240 seconds]
mon_aaraj has quit [Ping timeout: 240 seconds]
lisp123 has joined #commonlisp
mon_aaraj has joined #commonlisp
lisp123 has quit [Ping timeout: 276 seconds]
jmes has joined #commonlisp
frgo has joined #commonlisp
prokhor__ has quit [Ping timeout: 260 seconds]
tedwing has joined #commonlisp
waleee has quit [Ping timeout: 276 seconds]
mon_aaraj has quit [Ping timeout: 276 seconds]
mon_aaraj has joined #commonlisp
cage has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
serbest has joined #commonlisp
mon_aaraj has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 240 seconds]
tyson2 has quit [Remote host closed the connection]
Algernon69 has joined #commonlisp
treflip has quit [Remote host closed the connection]
Algernon69 has quit [Quit: Leaving]
mariari has quit [Quit: WeeChat 3.5]
szkl has quit [Quit: Connection closed for inactivity]
mon_aaraj has quit [Ping timeout: 276 seconds]
mon_aaraj has joined #commonlisp
rodicm has quit [Ping timeout: 256 seconds]
tyson2 has joined #commonlisp
<Josh_2>
Nice to see the Fukamachi article about Woo on planet lisp
<Josh_2>
Obv I am 46 days late to the party
<Duuqnd>
Is there some kind of de facto standard library for handling date and time in a nice (preferably CLOSy) way? I've found myself writing a date-and-time class twice now and would like to avoid duplicating more work.
Dynom has joined #commonlisp
<jeosol>
Duuqnd: Have you looked at local-time and simple-date-time libraries?
<Josh_2>
I have always used local-time, its very good
<Duuqnd>
simple-date-time looks exactly like what I was after, thanks!
<jeosol>
Duuqnd: That's the one I used most of the time.
<jeosol>
you are welcome
ttree has joined #commonlisp
<Josh_2>
The author is quek? If so the author has written that you should use local-time instead
<Duuqnd>
Didn't notice that, I'll use local-time instead then
cage has quit [Remote host closed the connection]
<jeosol>
After much back and forth, I finally, packaged one of my example use cases in a docker container image and have it run successfully. Build time ~ 42mins, and 6.75GB image size code + data (for the largest, smallest use case ~ 3GB). After testing, processing with docker container option much slower (HTTP response time) than running a simple REPL
<jeosol>
:') =(
<jeosol>
I guess the main benefit is that it's easier to move round now. This is with latest SBCL
tyson2 has quit [Remote host closed the connection]
livoreno has quit [Ping timeout: 276 seconds]
kpoeck has joined #commonlisp
<Josh_2>
Thats crazy
<Josh_2>
Your use case is stored in a variable so its saved in the lisp image?
<jeosol>
Josh_2: Good question. Essentially, this image is a worker and when launched has hunchentoot launched to listen for requests. Most of the large case is the data for it. It's a large simulation grid.
<jeosol>
If none of it is clear, I plan to give a talk in the next few months. It's painful to get the docker part to work, I am no software/devops guy, but had to learn it the hardway
ad-absurdum has joined #commonlisp
<Josh_2>
Is the data built by lisp?
<jeosol>
What the image contains, is essentially, how I run the case, I quickload my system, and load these large datasets. It takes longer to run the first time (with REPL) so I save intermediate objects so I can reload them later. I also dump a core of everything for faster startup
<jeosol>
Yeah, mostly. There are flat files (think csv files) and then I have classes that ingest those and I serialize them to file as intermediate step
lisp123 has joined #commonlisp
<Josh_2>
You have gigs of csvs that are you loading?
<jeosol>
Development with compile-and-run languages would be painful because to load the system takes time. But with incremental development, I can update the system little by little. Now the docker image(s) contains the workers in the state I need them so I just send request and get the HTTP response back
<jeosol>
Yes, I have large csv files I load. They are arrays that go into a grid, and for uncertainty, there are several versions (50) for the largest example.
<jeosol>
That's one limitation of the application, it takes a lot of memory to run it, because I use the arrays to advise the program to take better decisions.
<jeosol>
In the beginning, I tried writing results to databases, but writing was really slow, so I decided to just use arrays and save them to disk
lisp123 has quit [Ping timeout: 256 seconds]
<ad-absurdum>
After building the latest SBCL 2.2.6 and running the tests I had a test failure: "Invalid exit status: hide-packages.test.sh". Here is a short excerpt from the test log:
<ad-absurdum>
/ Running hide-packages.test.sh in COMPILE evaluator modeUnhandled SIMPLE-ERROR in thread #<HIDDEN-SB-THREAD:THREAD "main thread" The assertion (NULL *WEAK-PTRS*) failed with *WEAK-PTRS* =
<ad-absurdum>
(#<weak pointer: "SB-VM">).
<ad-absurdum>
Any ideas?
<Josh_2>
jeosol: writing to postgres is really fast if you use the correct types. But otherwise the way you are doing it seems really cool :D
<Josh_2>
You could also use bknr I suppose
<jeosol>
jeosol: I used postgres exclusively. It has a bulk write copy option which I learned about later later. But at the time, it's slow because I need to push lots of data fast -
<jeosol>
I think I am using cl-store
<Josh_2>
I see :)
<Josh_2>
What does your program do?
<jeosol>
I did look at bknr when I started
<Josh_2>
I remember my fren sent me a big data coding test he was given for a job he applied for, it came with a 3gb CSV and he had to perform certain operations on it as part of the test
<jeosol>
It's will be hard to explain, but I can use analogies. It's fluid simulation, something close will be weather simulation. A requirement for these problems is a grid, the finer the grid, the more detailed is the solution
<Josh_2>
I solved all the problems using CL, but I found that it was practically impossible (due to time) to not use structures with correct type data
<Josh_2>
I could not use classes and generic types, I had to specify the types in structures otherwise it took a very long time to complete
saura has joined #commonlisp
<jeosol>
Josh_2: The biggest I pushed to CL was 60GB and SBCL handled it well, though, I didn't save it, just got a file-handle and processed the data to another file
<Josh_2>
jeosol: yes you are right, I have no idea xD
<Josh_2>
So the larger the file, the higher the resolution of the grid
<Josh_2>
the more data to crunch, the faster you need to go
robin has quit [Ping timeout: 268 seconds]
<jeosol>
Josh_2: I didn't mean it in a bad way, but it's just hard to explain, on this forum. I will have pictures during the talk to make it clear
<Josh_2>
Is this a FOSS project?
robin has joined #commonlisp
<jeosol>
This is one part that computes F(X) for a given X, then the other parts is the optimizer part to find the best value of X that maximizes the objective function. But this part was the most critical and most difficult
saura has quit [Ping timeout: 240 seconds]
<jeosol>
Josh_2: No it isn't per se, not now, due to other issues beyond me. But I do plan to give access to students in less developed countries trying to do research as done in the west. But access is probably going to be online. For this use case, the container packages everything that is needed, code+data+3rd party exes need to run them
<Josh_2>
I'm in africa, can I get access? :sunglasses:
<Josh_2>
not that I would understand at all
<jeosol>
The problem is, the latency. On my computer, if I run a small case (one smaller example), it takes < 1 second on my local box. If I run to a docker still on my local box, it takes 3 seconds, and longer if I do a DNS lookup. SO the time begins to add up
<jeosol>
Josh_2: what country are you in?
<Josh_2>
SA
<jeosol>
nice
<jeosol>
The benefit is the student has none of the tools, expertise, etc, but has internet access, and can sacrifice the possibly high latency. Everything then reduces to a call.
<jeosol>
Josh_2: access is just receiving a token at this time, and use whatever language CL, Python to make the requests.
<Josh_2>
I can guarantee I will have high latency :joy:
<jeosol>
haha. I can't afford to put everything in clusters around the world, but it's possible later. Right now, resources reside in central US
vassenn has joined #commonlisp
anticomputer_ has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
kpoeck has quit [Quit: Client closed]
tyson2 has joined #commonlisp
Oddity has joined #commonlisp
morganw has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
vassenn has quit [Quit: Good bye!]
kpoeck has joined #commonlisp
cosimone has quit [Ping timeout: 260 seconds]
mon_aaraj has quit [Ping timeout: 276 seconds]
mon_aaraj has joined #commonlisp
szkl has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 240 seconds]
gxt_ has quit [Remote host closed the connection]
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
gxt_ has joined #commonlisp
mon_aaraj has quit [Ping timeout: 276 seconds]
yauhsien has joined #commonlisp
mon_aaraj has joined #commonlisp
jmdaemon has joined #commonlisp
Dynom has quit [Quit: WeeChat 3.5]
jmes has quit [Ping timeout: 246 seconds]
yauhsien has quit [Ping timeout: 276 seconds]
waleee has joined #commonlisp
tedwing has quit [Ping timeout: 246 seconds]
dra has joined #commonlisp
kpoeck has quit [Quit: Client closed]
rodicm has joined #commonlisp
akoana has joined #commonlisp
mixotricha has joined #commonlisp
rodicm has quit [Quit: Leaving]
mon_aaraj has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
serbest has joined #commonlisp
MajorBiscuit has joined #commonlisp
lisp123 has joined #commonlisp
mon_aaraj has quit [Ping timeout: 276 seconds]
lisp123 has quit [Ping timeout: 256 seconds]
mon_aaraj has joined #commonlisp
orestarod has quit [Ping timeout: 276 seconds]
shka has quit [Ping timeout: 276 seconds]
tedwing has joined #commonlisp
rendar has quit [Ping timeout: 248 seconds]
tedwing has quit [Quit: leaving]
defaultxr has quit [Ping timeout: 264 seconds]
pve has quit [Quit: leaving]
MajorBiscuit has quit [Ping timeout: 240 seconds]
tyson2 has quit [Remote host closed the connection]
edgar-rft has quit [Ping timeout: 246 seconds]
edgar-rft has joined #commonlisp
defaultxr has joined #commonlisp
morganw has quit [Remote host closed the connection]
mon_aaraj has quit [Ping timeout: 276 seconds]
mon_aaraj has joined #commonlisp
ecomcon has joined #commonlisp
<ecomcon>
Should I be creating subclasses solely to discriminate between methods?
<pjb>
ecomcon: if you need to.
<pjb>
ecomcon: can you ask a concrete question?
ttree has quit [Ping timeout: 260 seconds]
<TMA>
in my experience, the answer to this type of technical question is either really obvious to the asker as soon as they ask it; in the remaining cases the answer is usually "no, try thinking more"
<ecomcon>
pjb: sure. In a graphical application, I have a BINARY-PARTITION class with two fields, PRIMARY and SECONDARY, that point to each subdivision. I've subclassed BINARY-PARTITION into VERTICAL-PARTITION and HORIZONTAL-PARTITION, which have no fields, for the purpose of implementing separate DRAW and PICK methods.
<pjb>
If you didn't have subclasses, you'd have to add an ORIENTATION slot, and in the single method, test for it. It's better in terms of OOP, to define the subclasses, indeed, to define specific methods for them.
<ecomcon>
At first, BINARY-PARTITION had an ORIENTATION field, which told DRAW how to behave, but I thought that was essentially the logic of multiple dispatch, so I turned them into subclasses
<pjb>
ecomcon: notice that in CL we also have CHANGE-CLASS, so you can change the orientation easily.
<pjb>
ecomcon: seems good.
Brucio-61 has quit [Ping timeout: 276 seconds]
<ecomcon>
oh, right, "slot," not "field." I come from java. don't tell anyone.
dre has joined #commonlisp
theBlackDragon has quit [Remote host closed the connection]
theBlackDragon has joined #commonlisp
ecomcon has quit [Quit: disconnected]
edgar-rft has quit [Ping timeout: 246 seconds]
mon_aaraj has quit [Ping timeout: 246 seconds]
lisp123 has joined #commonlisp
dra has quit [Ping timeout: 276 seconds]
mon_aaraj has joined #commonlisp
lisp123 has quit [Ping timeout: 246 seconds]
serbest has quit [Quit: Leaving]
serbest has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 276 seconds]
edgar-rft has joined #commonlisp
Lord_of_Life has joined #commonlisp
serbest has quit [Client Quit]
nij- has joined #commonlisp
random-nick has quit [Ping timeout: 240 seconds]
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]