<aeth>
com.informatimago and xelf and ECL are officially ahead of the trend because they've been on Gitlab for forever.
warweasle has joined #lisp
beep-lord has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Denommus` has joined #lisp
Denommus has quit [Ping timeout: 256 seconds]
<rumbler31>
pjb: regarding trust, if I held that mindset I'm not sure how I would have gotten anything done.
ealfonso has quit [Ping timeout: 260 seconds]
schjetne has quit [Ping timeout: 248 seconds]
fisxoj has joined #lisp
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
innovati has joined #lisp
damke_ has joined #lisp
TCZ has quit [Quit: Leaving]
damke has quit [Ping timeout: 244 seconds]
ZombieChicken has quit [Quit: Have a nice day]
marusich has quit [Quit: Leaving]
elfmacs has joined #lisp
<aeth>
rumbler31: It definitely depends on your domain. For some domains, you have no choice but to pay thousands of dollars for some overpriced specialized software.
<rumbler31>
right
<aeth>
Probably not programming languages these days. Possibly HDLs, though.
<aeth>
Also things like CADs.
<rumbler31>
the discussion I meant to re-start was about debugging tools. beach mentioned something that suggested that in his experience, paid implementations have better debugging experiences and I wanted them to expound on that
dilated_dinosaur has quit [Ping timeout: 260 seconds]
<rumbler31>
I have no such experience so I wanted to know more
Pixel_Outlaw has joined #lisp
<aeth>
It wouldn't surprise me. Commerical software like that tends to focus on features to justify upgrades. e.g. integrated Prologs.
fikka has quit [Ping timeout: 256 seconds]
dilated_dinosaur has joined #lisp
eli_oat has joined #lisp
fikka has joined #lisp
smurfrobot has joined #lisp
surya has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 240 seconds]
eli_oat has quit [Quit: Leaving.]
smurfrobot has quit [Ping timeout: 240 seconds]
surya has joined #lisp
smokeink has joined #lisp
eli_oat has joined #lisp
fikka has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
Pixel_Outlaw has joined #lisp
innovati has joined #lisp
eli_oat has quit [Quit: Leaving.]
warweasle has quit [Quit: Leaving]
jameser has joined #lisp
schjetne has joined #lisp
eli_oat has joined #lisp
Oladon has quit [Quit: Leaving.]
terpri has joined #lisp
pjb has quit [Ping timeout: 260 seconds]
dddddd has quit [Remote host closed the connection]
pierpa has quit [Quit: Page closed]
fikka has quit [Ping timeout: 268 seconds]
damke_ has quit [Ping timeout: 244 seconds]
damke_ has joined #lisp
fikka has joined #lisp
schjetne has quit [Ping timeout: 240 seconds]
nicht has joined #lisp
nicht has quit [Max SendQ exceeded]
surya has quit [Remote host closed the connection]
schoppenhauer has quit [Ping timeout: 256 seconds]
schoppenhauer has joined #lisp
fikka has joined #lisp
karlosz has quit [Remote host closed the connection]
elfmacs has quit [Read error: Connection reset by peer]
schjetne has joined #lisp
<beach>
Good morning everyone!
<minion>
beach, memo from pjb: apropos 9:17 https://www.youtube.com/watch?v=ZJr81DtSwUc (loop for i below 10 sum i maximizing (sin i) into maxin collect (* i i) into squares finally (print (list maxin squares))) is conforming AFAIK. it has several accumulations clauses of different types… ;-)
<beach>
pjb: Thanks.
fikka has quit [Ping timeout: 268 seconds]
<beach>
rumbler31: I have no experience with commercial Common Lisp implementations, but I hear they are much better than the free ones for debugging. For my own experience, I still miss using GDB back in the days when I was programming in C. I find I can't do things with our free Common Lisp implementations that I could do then.
EvW has joined #lisp
<beach>
rumbler31: I do know what I would like to see for our free Common Lisp implementations, namely this: http://metamodular.com/clordane.pdf but it will require significant support from the implementation, so it probably won't happen with the existing free implementations.
karlosz has joined #lisp
jfrancis has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 240 seconds]
<akkad>
beach: does acl/lw have it?
jfrancis has joined #lisp
<beach>
I have no experience with commercial Common Lisp implementations.
<akkad>
is there any implementation of this you are aware of?
beep-lord has quit [Quit: WeeChat 1.6]
<akkad>
I see. thought you were contrasting with a commercial implementation
<beach>
Of what? Of Clordane? No. I designed it and nobody has implemented it.
jfrancis has quit [Remote host closed the connection]
Kevslinger has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
daniel-s_ has joined #lisp
fisxoj has quit [Quit: fisxoj]
EvW1 has joined #lisp
daniel-s has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 260 seconds]
EvW1 has quit [Ping timeout: 256 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
<akkad>
oh nice
himmAllRIght17 has quit [Ping timeout: 256 seconds]
himmAllRIght17 has joined #lisp
schjetne has quit [Ping timeout: 248 seconds]
<jeosol>
Morning beach.
jfrancis has joined #lisp
fikka has joined #lisp
<jeosol>
I have not gone through your linked pdf in detail, but does your design closely match gdb in c/c++ or it's different with added functionality.
<jeosol>
Also, what do you mean by "significant support from implementation", obviously man hours, but does this also mean it is likely to require lot of implementation details that it is likely to be very different for each free implementation
<jeosol>
also since SBCL is very popular, is this feasible to at least put efforts for that implementation.
<dtornabene>
i'm reading it now beach, but I'm also curious about jeosols second question
<jeosol>
As the designer, you are in better place to push this because it is going to be more clearer to you, and subsequently others who take time to study the document (and who may have used other debugging systems)
<beach>
OK, let's see...
<beach>
jeosol: I did not try to match GDB. I was considering something I would like for Common Lisp.
<beach>
jeosol: In particular, I won't use different processes. I want one thread to debug another thread, and the debugged thread could be the debugger.
fikka has quit [Ping timeout: 276 seconds]
<jeosol>
good, just wondering because I use to code in C/C++ but don't remember it that much.
<beach>
jeosol: I am totally confident that I would be unable to convince the maintainers of any current implementation, including SBCL, to add the support that Clordane requires.
<jeosol>
oh really?
<dtornabene>
interesting
<jeosol>
In your estimate, how much work, even if rough estimate,
<dtornabene>
i just finished it btw, seems like the implementation of this on sbcl wouldn't be....momentous? but then I have the barest knowledge of sbcl internals
<jeosol>
You are right, the guys with the knowledge of internals will have to buy into this
<akkad>
beach: fork :P
* akkad
imagines the internals are a art few have a grasp of.
<beach>
jeosol: I don't know SBCL well enough to give an estimate. It requires compiler support and, as I understand it, the SBCL compiler is very complicated.
<jeosol>
and possibly implement using a style with as little modification to the original code base.
<jeosol>
Ok, I thought as much.
jfrancis has quit [Ping timeout: 268 seconds]
<jeosol>
if it has to involve working deep in the compiler, then it will require major effort for sure
<beach>
Worse,...
<beach>
The SBCL maintainers will likely say that it might slow down the generated code, and reject it before even considering it.
<dtornabene>
talk about a subject in need of a good book, a serious thorough book on SBCL internals would be *awesome*
<jeosol>
for my applications, I wouldn't say I have not had a need for debugger, but I ensure my systems are testing in very small units, and when CLOS objects are used, I have constructor functions for easy testing.
<jeosol>
however, my debugging probably sucks, combination of inlet and outlet statements to function (stopped this), SLDB, good old print statements, ...
<jeosol>
beach: on the issue of rejecting, it would have been nice if it was even possible to scope out requirements and what might change or be impacted in the context of SBCL
<jeosol>
and also the benefits of having such a functionality in a free implementation.
zooey has quit [Remote host closed the connection]
<beach>
dtornabene: You have to consider that SBCL has a long history and the internals have very likely become a bit messy over time.
damke_ has joined #lisp
zooey has joined #lisp
schoppenhauer has quit [Ping timeout: 248 seconds]
<dtornabene>
beach: for sure, i spent a few hours recently just reading, taking line counts, investigating the layout. It seemed like a huge task to get on top of the system as a whole, but its something I'd like to devote a non-trivial amount of time to over the next 12 months or so
<dtornabene>
it seems like something that would be useful to the community and enlightening
<beach>
jeosol: I totally think that we need a more modern implementation. That is why I am not willing to put any effort into SBCL. In particular, if I have to convince the current maintainers to make changes that are very unlikely to be accepted, I prefer putting my energy into something more modern.
schoppenhauer has joined #lisp
damke has quit [Ping timeout: 244 seconds]
<jeosol>
beach: makes sense.
<jeosol>
but what do you mean by "modern"
<jeosol>
modern a la Arc or still CL but better implementation
<beach>
jeosol: One that has first-class global environments, my generic dispatch, my LOOP implementation, my garbage collector, the debugging support I want, etc, etc.
<jeosol>
Beach Common Lisp (BCL)
<jeosol>
nice.
<jeosol>
Steel Bank/Beach Common Lisp
<beach>
jeosol: It is called SICL, which doesn't mean anything.
<jeosol>
Good points. I take it there is not way to implement these new functionalities or add them in existing implementation
<beach>
jeosol: There is always a way to implement them in an existing implementation, but it is a question of how much work it requires, and whether the maintainers are willing to accept it.
<loke>
beach: what GC are you using?
<jeosol>
Very nice. I read the README.
<beach>
loke: Hold on...
<jeosol>
It will really be nice to get a modern implementation
<jeosol>
By the way, are big companies using SBCL or some of the other free implementations, such that they could fund some of these type of projects
<jeosol>
Sometimes, it is not just funding, but interesting and keen participants.
<jeosol>
This could be an opportunity to take CL to be more modern and add more battle tested, and proven libraries so some library class "like Boost C++ libraries" that eventually make their way into the core.
<beach>
loke: A sliding collector for the nurseries (per-thread) and a combination of mark-and-sweep and a traditional malloc/free for the global collector.
<beach>
jeosol: Google is using SBCL.
fikka has quit [Ping timeout: 240 seconds]
<loke>
beach: So it's not compacting?
<beach>
loke: The sliding collector is.
<loke>
beach: I see.
<beach>
[Now, we are going to get the "what about fragmentation" remark]
<jeosol>
I say we apply for grant, so pull some resources, especially with the merits of the new system.
<beach>
As Wilson et all showed a few decades ago, fragmentation only exists in programs that don't do anything useful.
<loke>
beach: Does it have stack-allocation when objects can be proven to have dynamic scope?
<beach>
loke: I am planning that, but I haven't given it much thought. I want it to be correct first.
<beach>
jeosol: And then who would I pay to implement it with that grant money?
<loke>
The benefit of compaction isn't that fragmentation is sliminated per se, but that allocations can be much faster if the free memory is clustered.
<beach>
loke: I can still do that.
trocado has quit [Ping timeout: 265 seconds]
<jeosol>
Or may be fork off SBCL now, just like the latter from CMUCL back then. But it will likely be more difficult if the base code is messy. For large codes, I know first hand how important it is to get the base right.
<beach>
loke: In the nursery, allocation is just bumping a pointer.
<jeosol>
It is not so much like pay. A committee/trust is formed with you as the oversee.
<loke>
beach: Right. That's what makes GC-language allocations so much faster than C, for example.
<beach>
loke: In the global collector, allocation is made in big blocks to promote many objects at the same time.
<loke>
beach: Makes sense.
<loke>
beach: what does it do when a global object gets GC'ed?
<akkad>
is ironclad not considered secure now? re: statement on "awesome lisp"
<beach>
jeosol: My hunch is that it would be even more work to transform SBCL into a modern implementation than it would be to create a new one.
<jeosol>
It is essentially a project that is funded with the main designer at the helm.
<jeosol>
beach: I agree with you last point. Yes, especially if the design is radical. It may be better to start of a fresh base where things are layered systematically.
<loke>
akkad: Ironclad hasn't had any known vulnerabilities, AFAIK. It doesn't suffer from buffer overruns and such, and the algorithms seems to be solidly implemented.
<jeosol>
*your
<akkad>
loke: thanks
<loke>
akkad: but, it's not much maintained, so support for newer ciphers is lacking.
<akkad>
gotcha.
<beach>
loke: Nothing special. I have a linked list of two-word header objects that use mark-and-sweep. When a dead header object is found, the equivalent of free() is called on the "rack" (the part that contains the data).
fikka has joined #lisp
<loke>
beach: But didn't you say that a single allocation contains many objects?
<beach>
jeosol: I still wouldn't know how to spend the money from a grant.
<loke>
beach: hire a developer or two?
<beach>
loke: Name two!
<loke>
Hmm
igemnace has joined #lisp
<beach>
loke: Yes, but objects will have to be free'd individually when they die.
<loke>
I'd propose myself, but there are at least 3 barriers preventing that to happen :-)
<beach>
There you go.
<loke>
beach: oh, you can do that?
<loke>
Single-allocation/multiple-free?
<loke>
that would suggest it's not _actually_ malloc, but rather somthing malloc-like?
<beach>
Sort of, yes. The nursery could tell the global collector that it needs a bunch of objects at once.
innovati has quit [Read error: Connection reset by peer]
<beach>
Yes, I am thinking Doug Lea's allocator, but modified.
<loke>
I see.
<beach>
There are plenty of advantages of this scheme. For one thing, an object in the global heap never moves.
<beach>
This is good for EQ hash-table keys and for functions.
fikka has quit [Ping timeout: 256 seconds]
<beach>
And it avoids cache some invalidation in the processor.
innovati has joined #lisp
jameser has quit [Read error: Connection reset by peer]
jameser_ has joined #lisp
<beach>
I would need people who 1. are available for hire, 2. know about compiler techniques, 3. know about Common Lisp details, 4. know about garbage collection, 5. know the details of CLOS, 6. know about reusability, maintainability, portability.
<beach>
I am betting that the handful of people who fit that profile are already working on some exiting free or commercial implementation.
fyodost has quit [Quit: Leaving]
<loke>
beach: True.
<loke>
Seems like that with a lot of interesting CL project.
innovati has quit [Read error: Connection reset by peer]
<beach>
Indeed.
smurfrobot has joined #lisp
<loke>
(where “interesting” is orthogonal to “useful”)
<jeosol>
Well, it also depends, there are people coming up the ranks that may not know everything now
<loke>
And “popular”
<jeosol>
My code uses most CLOS but I had to read Sonja's book, and a bunch of others to get good over time.
fikka has joined #lisp
shka_ has joined #lisp
<jeosol>
Looking at the list, I think you want people who are heavily invested in CL overall, and true some may be working on other projects now
<beach>
jeosol: Oh, I see what you are saying. I should 1. Apply for a grant, and 2. Hire you.
<jeosol>
hahahahahah
<jeosol>
I believe in team work and team effort
innovati has joined #lisp
<jeosol>
I am not the most person qualified for this task. What I meant above is the person who has the main design and how all the parts fit, will lead the efforts early on.
<jeosol>
But yes, everything will start with a grant, like some funded project
kerrhau has joined #lisp
kerrhau has joined #lisp
kerrhau has quit [Changing host]
<beach>
jeosol: Here is what I think. I think I should continue doing what I am doing now, i.e. working on the implementation and doing the research to invent techniques of making it modern, good, and fast. Then, people who are sufficiently knowledgeable and sufficiently interested will show up spontaneously. Like Bike, heisig, drmeister, etc. And there are already signals that some more people will join.
<jeosol>
I think it's the team that matters most as long as they believe in the final objective, agree on the common grounds, ..., off and running
igemnace_ has joined #lisp
<beach>
jeosol: So I think for this project, it's not the right thing to start with a grant.
igemnace has quit [Read error: Connection reset by peer]
<jeosol>
Well, that is good. I support that
<jeosol>
I didn't know you have gone far with this, hence my grant comment. I thought it is something just starting out.
<beach>
jeosol: Besides, Common Lisp has been off the radar for grant-giving institutions for the past half a century or so.
<jeosol>
If you have gone far, by any means, I would say continue, because changes are likely going to slow and impede things now.
smurfrobot has quit [Ping timeout: 256 seconds]
<beach>
jeosol: The Cleavir compiler framework is already used for Clasp. And karlosz has a GSoC project to use it for CLISP. jackdaniel has plans to use it for ECL. And in Marbella, there were rumors that someone might use it to write a new SBCL compiler.
fikka has quit [Ping timeout: 256 seconds]
<beach>
minion: Please tell jeosol about Cleavir.
<minion>
jeosol: Cleavir: A project to create an implementation-independent compilation framework for Common Lisp. Currently Cleavir is part of SICL, but that might change in the future
<beach>
jeosol: And, obviously, the compiler is a HUGE part of a new implementation, so a big chunk of code is already done.
<jeosol>
When I started working on my code/application. I got to a point, where I was considering changing language since people start saying I should consider Clojure. I actually posted this question on Twitter and Paul Graham advised against Lisp, and only agreed when I mentioned my code is heavily CLOS-based
<jeosol>
Eventually, I stayed with it. A buddy told me to use something else as a condition to come along.
<jeosol>
beach: that's great. Cleavir is already since many usage already.
<beach>
The fact that Cleavir can adapt to totally different implementations is an indication that it is modular and maintainable.
<beach>
So it is a good candidate for what I want from a "modern" implementation.
<jeosol>
Clasp is something I planned to take a look at after discussing ML libraries and it was recommend to use clasp and link to other ML/AI libraries and make them accessible via CL
stardiviner has joined #lisp
<beach>
Contrast that with the SBCL compiler that has assumptions about that particular implementation all over the code.
kerrhau has quit [Ping timeout: 248 seconds]
<jeosol>
I see your point. It is better to start fresh. For large code bases, it usually works better than way and you get more productivity as you add more layers on top.
kmurphy4 has quit [Quit: kmurphy4]
fikka has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
<beach>
loke: Interestingly, the fact that the global garbage collector does not move things around, makes this ideal for interoperation with foreign code like C. But such interoperation is not one of the goals of SICL. :)
asarch has quit [Read error: Connection reset by peer]
kerrhau has joined #lisp
kerrhau has joined #lisp
kerrhau has quit [Changing host]
<jeosol>
beach: to echo your "reusability, maintainability, ...", point, it is very point and you can see from the use of Cleavir component in several projects.
<jeosol>
s/point/important
<beach>
Right. I spend a lot of time on that stuff. I am not perfect of course, so occasionally I get it wrong.
schjetne has joined #lisp
<karlosz>
to add to beach's point, the Cleavir to CLISP interface is only about 900 lines or so
<beach>
Wow. That's great!
<karlosz>
and it does the translation in a linear pass :)
<karlosz>
since dominator calculations are already all there
fikka has quit [Ping timeout: 265 seconds]
<jeosol>
karlosz: thanks for that info
fikka has joined #lisp
<beach>
So the goal of Cleavir is not only to provide a compiler framework, but also to include all kinds of modern compiler optimization techniques so that a client implementation can pick and choose what optimizations it wants to apply and in what situation.
<jeosol>
more like a consistent base for all implementation to pick from
<beach>
Some of these optimization techniques can be used as published. Some need to be adapted to the specific situation of Common Lisp (nested functions, threads, closures, etc). Others need to be invented from scratch (like the path replication stuff we published in ELS).
<jeosol>
should reduce the overall work in the implementations since there is a common base.
<beach>
Exactly.
<beach>
jeosol: Now try to do that with (say) the SBCL compiler.
<beach>
jeosol: It would take more effort than a total rewrite.
<jeosol>
beach: you got me. I am convinced and sold. Definitely not possible, so forking it wouldn't work
<beach>
Good! :)
<jeosol>
Layered software/code is a beauty, it takes almost no effort to add new features or corner cases.
<karlosz>
one big obstacle to compilers is just visualizing the IR. sbcl still odesn't have any good tools for doing that, even after 30 years of existence
<jeosol>
It will definitely be more work
<karlosz>
whereas i can say that the cleavir visualization tools really cut down on debugging time
<jeosol>
hasn't been 30 years, or going back to CMUCL
<jeosol>
*has it?
<karlosz>
going back to CMUCL, the compiler is practically the same
fikka has quit [Ping timeout: 256 seconds]
<karlosz>
in fact, if you want o learn about sbcl internals, its probably still better to go back to the cmucl docs
<jeosol>
Merci
<beach>
Yeah, the Graphviz visualization stuff really helps.
<jeosol>
that's what I did, I started with CMUCL before switching completely circa 2008/9
<jeosol>
With critical mass, SICL will start moving along
<beach>
But I assume you are busy with your own stuff, just like most other people.
<beach>
loke: Oh, that too. I should include it in the list.
<loke>
:-)
karlosz has quit [Quit: karlosz]
<beach>
Also CLOSType, a Common Lisp implementation of OpenType stuff.
ZigPaw has quit [Ping timeout: 268 seconds]
<loke>
Indeed
<jeosol>
I have been trying to learn ASDF as Fare is planning to leave at some point so he told me. Beach, I can work on multiple projects. Most of the work I was doing on that application is for the backend which is mostly complete
<loke>
That, and a font shaper.
<beach>
"shaper"?
<jeosol>
beach: the list of libraries is part of the overall SICL offering?
<loke>
beach: basically what Harfbuzz does.
<beach>
jeosol: No, it's part of my LispOS plan.
fikka has joined #lisp
<loke>
It processes text, and generates a sequence of glyphs and their precise location where they should be drawn
<beach>
Got it.
<beach>
jeosol: SICL is only one line in that list: "A Lisp system with first-class global environments"
<jeosol>
I see. Impressive list.
<jeosol>
Anyone working on the graphviz one
<LdBeth>
loke: does that support ligatures or plans to support it?
<jeosol>
Library for two-dimensional graph layout
<jeosol>
I guess there is still more stuff to be added especially in the utilities part
fikka has quit [Ping timeout: 240 seconds]
<loke>
LdBeth: Yes. The shaper is what provides that
<loke>
LdBeth: McCLIM already supports it in my Freetype branch. What Beach is talking abou tis a pure-Lisp implementation.
<jeosol>
are you considering things around data manipulation arrays (e.g., numpy, pandas as in pythong), machine learning/AI, even if down the line
ZigPaw has joined #lisp
fikka has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nickenchuggets has quit [Quit: Leaving]
nickenchuggets has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
schjetne has quit [Ping timeout: 256 seconds]
igemnace_ is now known as igemnace
<beach>
jeosol: I don't think anyone is working on the Graphviz stuff.
<beach>
jeosol: There are many more things to be added.
vlatkoB has joined #lisp
<beach>
jeosol: For applications, I am only able to write a list of the ones that I personally would like to see and that I know that we don't have.
<jeosol>
my background is mostly in the optimization space
<jeosol>
I have looked at CLML and Gabor Melis MGL code, they have very useful components
<beach>
Like linear programming and stuff?
<jeosol>
Yeah, I did some of that stuff, OR area, most optimization in general
<beach>
I see.
<beach>
My wife was on the CPLEX team before retiring last January.
<jeosol>
wow, really
<jeosol>
that's insane man....
<beach>
She was in charge of the documentation.
<jeosol>
no way, that means me and her shouldn't be in the same room
<beach>
Heh.
<beach>
It might actually happen if you come to ELS some time.
<jeosol>
people talking about optimization tend to be carried array. very impressive, I need to take a look at the stuff again.
<jeosol>
arguing about constraints, convergence, etc
<jeosol>
I think there are expertise littered around that can be converged which is why I mentioned the effort of the individuals involved.
<beach>
Sure.
<beach>
OK, Monday mornings are crazy around here. I'll be off and on for the next few hours.
<jeosol>
oh I will definitely come to ELS. I submitted an abstract for a conference in China and one due next week for a conference here. This is also the lisp work
<beach>
Great!
<jeosol>
No worries, it is past midnight here, should log out soon.
<jeosol>
But good stuff and thanks for the link.
<jeosol>
You work at U Bordeaux or where?
<beach>
Yes, but I am close to retirement.
<beach>
So moving away from direct involvement, spending more time on my own stuff.
<jeosol>
Ok. Nice.
igemnace has quit [Quit: WeeChat 2.1]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Autolycus has joined #lisp
makomo has joined #lisp
fikka has joined #lisp
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
gigetoo has quit [Ping timeout: 260 seconds]
Bindler has quit [Ping timeout: 268 seconds]
shka_ has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 248 seconds]
stardiviner has left #lisp ["Killed buffer"]
random9899 has quit [Quit: Leaving]
damke has quit [Read error: Connection reset by peer]
Naergon has quit [Remote host closed the connection]
damke has joined #lisp
gigetoo has joined #lisp
fikka has joined #lisp
schjetne has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
daniel-s_ has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
daniel-s_ has joined #lisp
flamebeard has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
flamebeard has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
flamebeard has joined #lisp
flamebeard has quit [Read error: Connection reset by peer]
flamebeard has joined #lisp
fikka has joined #lisp
pagnol has joined #lisp
schjetne has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 256 seconds]
varjag has joined #lisp
nickenchuggets has quit [Read error: Connection reset by peer]
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 244 seconds]
hhdave has joined #lisp
smokeink has quit [Remote host closed the connection]
hhdave has quit [Ping timeout: 256 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 244 seconds]
thoxdg has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
<hajovonta>
I wanted to contribute to Rosetta Code, but the site is not working properly
_cosmonaut_ has joined #lisp
fikka has joined #lisp
Folkol has joined #lisp
damke has quit [Ping timeout: 244 seconds]
phenoble has joined #lisp
pagnol has quit [Ping timeout: 265 seconds]
damke has joined #lisp
dtornabene has quit [Remote host closed the connection]
damke has quit [Ping timeout: 244 seconds]
Autolycus has quit [Quit: Connection closed for inactivity]
jfrancis has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
goreye has joined #lisp
jfrancis has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 265 seconds]
damke has joined #lisp
quazimodo has joined #lisp
cmoore has joined #lisp
cmoore is now known as clintm
jmercouris has joined #lisp
clintm has quit [Changing host]
clintm has joined #lisp
damke has quit [Ping timeout: 244 seconds]
jmercouris has quit [Remote host closed the connection]
damke has joined #lisp
jmercouris has joined #lisp
<jmercouris>
how do I get the binary representation for an object in lisp?
scymtym has quit [Ping timeout: 268 seconds]
<jmercouris>
I want to go like this "some string" --> 01101101010101010101 --> "some string"
<shrdlu68>
String->octets, then octets->bit vector.
<jmercouris>
shrdlu68: how does one go from bit vector back to the object?
<shrdlu68>
Same route in reverse.
<jmercouris>
Is there a function octects->String?
<jmercouris>
I bet there is, that seems obvious
<shrdlu68>
String->octets is widely implented, for example in ironclad and babel.
<jmercouris>
Looks promising, thanks!
damke has quit [Ping timeout: 244 seconds]
hjudt has joined #lisp
<beach>
jmercouris: You couldn't get from a binary representation to an object in general.
<jmercouris>
beach: basically only for "primitive data types"?
DataLinkDroid has quit [Ping timeout: 240 seconds]
<jmercouris>
there is nothing like Python's pickle in lisp?
<beach>
jmercouris: It might work with some restrictions, yes. But it would be very implementation specific.
<beach>
jmercouris: You would have to tell me what Python's pickle is doing.
<shrdlu68>
There are several serialization libraries, perhaps those that do binary serialization could be useful.
<jmercouris>
beach: "The pickle module implements a fundamental, but powerful algorithm for serializing and de-serializing a Python object structure. "Pickling" is the process whereby a Python object hierarchy is converted into a byte stream, and "unpickling" is the inverse operation"...
<jmercouris>
beach: are there unsettable fields/properties about an object in common-lisp?
<beach>
Sure, you can serialize things. But that's not the same as getting the binary representation.
<jmercouris>
e.g. during the reserialization there are some things you could not recreate?
<jmercouris>
what is the difference between serializing to binary, and the binary representation?
<beach>
I don't know where to start.
<jmercouris>
shrdlu68: babel has both string-to-octets and octets-to-string
<beach>
PRINT is a very good serializer. It produces output in the form of characters. If you convert those to UTF-8 as most Common Lisp systems would, then you serialize to binary.
<shka>
jmercouris: you can use cl-store
<shrdlu68>
jmercouris: Yep, so does ironclad and most packages that deal with networks protocols.
<beach>
jmercouris: But that has nothing to do with how the object is represented internally.
<shka>
it is simple to use
<jmercouris>
beach: well, I am not necessarily interested in how it is represented internally, just in a way to serialize and deserialize the objects
<jmercouris>
and to take the serialized form, and be able to input it in some reserializer and create an "identical" object
<beach>
jmercouris: And, you can de-serialize with READ. But there are restrictions, just like there must be in Python. You can't get an EQ object back.
<jmercouris>
Right, that is what I was thinking when I asked about "unsettable properties"
<beach>
jmercouris: "how do I get the binary representation for an object in lisp?"
<jmercouris>
ah yes, my question was stupid indeed
<jmercouris>
sorry!
<shka>
cl-store works on lists, vectors, instances of classes, structs (for sbcl), hash-tables..
<shka>
it basicly just works
<beach>
jmercouris: I recommend PRINT and READ.
<shka>
you can use it
<phoe>
a human-readable text representation is a very specific case of a binary representation of an object
<phoe>
but nonetheless a binary representation
<jmercouris>
beach: The problem is, I need to be in binary
<beach>
I just told you that it is.
<jmercouris>
the reason being that I have this idea I'm going to try to do
<jmercouris>
okay fine, I would then need to take the character representation and turn it into a binary stream of some text encoding and decode it
<beach>
jmercouris: PRINT already does that.
<beach>
jmercouris: And READ does the opposite.
<_death>
in many cases, READ is unsuitable.. and serialization of arbitrary objects is often not a good idea anyway.. it's better to think about your external representation without reference to any particular programming language
<jmercouris>
I agree, pickling in general is a bad idea
<jmercouris>
I just want to test a really specific use case
<jmercouris>
I would like to turn a string into a set of QR codes (as a video)
<jmercouris>
and then have a camera watch the video, and decode the video of QR codes
<beach>
That is yet another, very different, question.
<jmercouris>
I just wanted a simple way to get a bunch of bits for some representation of some thing to test with
<jmercouris>
I know about existing CL QR code libs, I might end up inventing a version of my own, but I just thought it was a cool idea
<jmercouris>
you could sort of stream a whole bunch of data in video format, to transfer more substantial things
<shka>
jmercouris: but you will need constant size of binary?
<shka>
isn't that the case?
<jmercouris>
shka: what do you mean?
<_death>
so you can encode the string to an octet vector, then use that to produce a QR code, and do the other way around on the side side
<thoxdg>
standard posix interface using cffi, virtual file system, agile web
<shka>
i se links
<shrdlu68>
A while back I ventured into compression, and wrote an arithmetic coding implementation in CL. It appears modern lossless compression has been reduced to a statistical modelling challenge, i.e, given a stream of bits, try and predict the next bit in the stream. Is anyone interested in creating a prediction function and testing it? I could create a library that makes testing out prediction functions easy
<shrdlu68>
through and extensible arithmetic coding implementation.
damke has joined #lisp
<thoxdg>
shrdlu68: should this also solve linear programming ?
<thoxdg>
we're only lacking in semantic data about programming languages, they even self compile now
<thoxdg>
i'm thinking about canonical representations of program code
quazimodo has quit [Ping timeout: 240 seconds]
minion has quit [Disconnected by services]
minion has joined #lisp
zhrek` has joined #lisp
<shrdlu68>
thoxdg: Not sure, a prediction function simply receives a stream of bits and outputs the probability that the next bit will be 1.
fluxi- has joined #lisp
<shka>
does not sound terribly complicated to be honest
<thoxdg>
shrdlu68: like a markov chain ?
quazimodo has joined #lisp
<shrdlu68>
thoxdg: Yes, a simple Markov chain outdoes gzip, for example.
<thoxdg>
all in all it's just a convolution
<shrdlu68>
In terms of compression ratio, not speed.
koenig1 has joined #lisp
<shrdlu68>
It's a very interesting problem space.
damke has quit [Read error: Connection reset by peer]
<holycow>
i'm running debian 9 and trying to install sketch via quicklisp
f32ff has joined #lisp
<thoxdg>
well if you don't represent entropy of your prediction function the model should leak entropy
getha has joined #lisp
aoh__ has joined #lisp
cods_ has joined #lisp
<holycow>
i get the following error: Failed to find the TRUENAME of /usr/share/common-lisp/source/cl-cffi/toolchain/package.lisp: No such file or directory
gorgor_ has joined #lisp
<holycow>
fair enough. cl-cffi is installed and /tolchain/ppackage.lisp is not there
<holycow>
anyone else run into this problem?
<thoxdg>
holycow: i don't know cl-cffi, only github.com/cffi/cffi
<jmercouris>
beach: I'm not just waiting to tell you how you are wrong :D, I was afk
<jmercouris>
beach: mostly I am asking to understand
benkard has joined #lisp
<jmercouris>
s/mostly/most of the time
<thoxdg>
maybe you can have better luck with quicklisp/cffi
hhdave has joined #lisp
<holycow>
thoxdg: well let me try uninstalling and see what ql does
<thoxdg>
shrdlu68: how is the actual binary result not a valid compression function ?
vsync has joined #lisp
<thoxdg>
for self teaching of rnn for instance
bexx has quit [Ping timeout: 240 seconds]
salva_ has joined #lisp
bexx has joined #lisp
oldtopman has joined #lisp
devn has joined #lisp
kori has joined #lisp
kqr has joined #lisp
ravndal has joined #lisp
<thoxdg>
is there a way for clisp to not load extension packages ?
orivej has quit [Ping timeout: 240 seconds]
jmercouris has quit [Remote host closed the connection]
pierpal has quit [Read error: Connection reset by peer]
siraben` has joined #lisp
<holycow>
allright, got it working
<holycow>
thanks thoxdg
<thoxdg>
cffi is awesome
siraben has quit [Ping timeout: 265 seconds]
<thoxdg>
is it netsplit or quiet ?
<holycow>
i did not see a large split, so a bit of both?
<thoxdg>
does clozurecl run on bsd ?
<thoxdg>
or ecl
<holycow>
i don't know, sorry. maybe someone else does.
EvW has joined #lisp
dx_ has joined #lisp
thoxdg has quit [Quit: Lost terminal]
dx_ has left #lisp [#lisp]
ym has joined #lisp
ym has quit [Client Quit]
shangul has joined #lisp
dx_ has joined #lisp
dx_ has quit [Client Quit]
thodg has joined #lisp
<shangul>
https://apaste.info/2pWi => I tried to read contents of a file. This is SBCL. Where was I wrong?
ym has joined #lisp
jfrancis has joined #lisp
jfrancis has quit [Remote host closed the connection]
holycow has quit [Quit: Lost terminal]
hjek has joined #lisp
<scymtym>
shangul: do you want to read the contents as Common Lisp code or as a string?
<shangul>
scymtym, I want to learn. if you give me something that I may read more, that would fine
<shangul>
I just wanted to read all texts and store it in a variable
<shangul>
and then write it to console
<scymtym>
shangul: if you know how to use libraries, you can use the function ALEXANDRIA:READ-FILE-INTO-STRING to do exactly that
<shangul>
okay, but what's wrong in my code? purpose of read and with-open-file is something else than I'm supposing?
<scymtym>
the function CL:READ is for reading Common Lisp code from a stream. also, READ only reads a single form, not everything in the file
<shangul>
a single form?you mean a single line?
<scymtym>
no, a form is chunk of Common Lisp code
<shangul>
a '(something...)'?
ym has quit [Quit: Leaving]
ym has joined #lisp
<scymtym>
basically, yes
<scymtym>
you can use CL:READ-LINE to read one line (as a string) at a time. there is no builtin function to read a whole file
<shangul>
thanks
<scymtym>
if you are just starting, reading a book might be a good idea
<scymtym>
minion: tell shangul about pcl
<minion>
shangul: please look at pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<scymtym>
minion: tell shangul about gentle
<minion>
shangul: please see gentle: "Common Lisp: A Gentle Introduction to Symbolic Computation" is a smoother introduction to lisp programming. http://www.cs.cmu.edu/~dst/LispBook/
<shangul>
I'm on the first book, now.
ym has joined #lisp
<scymtym>
the former is supposed to be suitable for people with programming experience
makomo has joined #lisp
<scymtym>
great, you should be all set, then
<shangul>
yeah some people here suggested that to me. as I already know a few languages
<shangul>
scymtym, but how about the second?
<scymtym>
i don't know anything about it personally, but it is often recommended here to people without programming experience
<shangul>
thanks again
<scymtym>
shangul: i have to go to a meeting now. good luck and maybe give ALEXANDRIA:READ-FILE-INTO-STRING a shot
<shangul>
okay, I'll do
pierpal has joined #lisp
<shangul>
minion: Do you like banana?
<minion>
Do you like banana: An error was encountered in lookup: Parse error:URI "https://www.cliki.net/Do you like banana?source" contains illegal character #\ at position 24..
hjek has quit [Remote host closed the connection]
siraben` has quit [Remote host closed the connection]
<flip214>
minion: do you encode your%3f inputs?
<minion>
do you encode your%3f inputs: An error was encountered in lookup: Parse error:URI "https://www.cliki.net/do you encode your? inputs" contains illegal character #\ at position 24..
kmurphy4 has joined #lisp
<shrdlu68>
thodg: I don't understand the question.
fikka has quit [Ping timeout: 265 seconds]
pierpal has quit [Read error: Connection reset by peer]
jmercouris has joined #lisp
salva_ has quit [Remote host closed the connection]
damke has joined #lisp
fikka has joined #lisp
clintm has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<hjek>
thodg: nice overview. there's not that much documentation when you follow the links to github, or on the cliki itself, so perhaps a few links to relevant resources might be good?
milanj has quit [Quit: This computer has gone to sleep]
<thodg>
hjek: they're trivial wrappers so the POSIX doc is sufficient
<thodg>
or even the headers themselves, it's truly for C coders to discover Lisp
milanj has joined #lisp
<hjek>
not for Lisp coders to discover C?
<thodg>
hjek: well why not but it's a big world with many operating systems conforming more or less to a few APIs
samla has joined #lisp
<thodg>
but cffi-grovel provides good abstractions
samla has quit [Client Quit]
<thodg>
even when you wrap function calls, the flags differ from systems to others
<thodg>
so the os manuals still apply
<thodg>
what is not written is that each package is nicknamed without cffi-prefix so if one day you have a posix implementation in CL the wrapper code still applies
<thodg>
wrapped*
fikka has joined #lisp
Bike has joined #lisp
<thodg>
it would prove it's only an artificial link to C to maintain a UNIX system
<thodg>
or if Mezzano starts copying UNIX
goreye has quit [Ping timeout: 260 seconds]
_cosmonaut_ has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<thodg>
hjek: what i meant is that unix manuals are available for almost all functions but you're right some documentation is due
<thodg>
i was wondering about why there are so many cffi wrappers around almost for each webserver, and i found out that the UNIX way of sorting functions in header files is good enough for most purposes
kmurphy4 has quit [Quit: Leaving]
hjek has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 245 seconds]
scymtym has joined #lisp
<hajovonta>
is there some good introductory read on implementing simple DSLs in Common Lisp?
damke has quit [Ping timeout: 244 seconds]
samla has joined #lisp
<thodg>
hajovonta: i don't know, all the Lisp I wrote could be called DSLs
<thodg>
right ?
<thodg>
or do you mean like LOOP ?
<hajovonta>
right; there are a few points, maybe I would leave out parentheses
<hajovonta>
from the beginning and end of the command, definitely; and from the middle of the commands, maybe
<thodg>
lisp is very fluid so what you write can be very close to actually writing domain language in Lisp
<beach>
hajovonta: On Lisp is basically all about DSLs.
samla has quit [Client Quit]
epony has quit [Read error: Connection reset by peer]
<hajovonta>
thanks - I look at it again, it was a long time I have read that
<hajovonta>
I personally like parentheses, but soon I will demo CL for my colleagues and I want to present some simple and useful examples
hjek has joined #lisp
Kundry_Wag has joined #lisp
epony has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
damke has joined #lisp
scymtym has quit [Ping timeout: 265 seconds]
Kevslinger has joined #lisp
<beach>
hajovonta: Don't demo it for your colleagues.
<beach>
hajovonta: Even if you hide the parentheses, they very likely won't be convinced.
<beach>
hajovonta: Once you say it's Common Lisp under the hood, they will lose interest.
<jackdaniel>
say it is a cool new language inspired by the javascript (but it doesn't work on the browser)
hjek has quit [Quit: Leaving.]
<hajovonta>
I don't really want to convince them, they are interested in CL already, just want to show how new syntax can be introduced, in some simple way.
<shrdlu68>
... | grep -vi "lisp"
<hajovonta>
we hold demo sessions for each other with lesser-known languages
<jmercouris>
I attempt to search in a lisp buffer and that happens
<jmercouris>
happens even without slime open
<hajovonta>
i expect the idea of pushing new definitions into a running image will be novel enough for the first time
<jmercouris>
which is what really doesn't make sense to me
<shka>
jmercouris: emacs question i think
<jmercouris>
shka: yeah, but #emacs was not very helpful
<jmercouris>
I guess I'll ask again
<hajovonta>
makomo i plan to demonstrate some control execution changing macros, which is unique to lisp
karswell_ is now known as karswell
<makomo>
hm, like?
jmercouris has quit [Remote host closed the connection]
<hajovonta>
for a simple example we can implement three-way if.
<makomo>
ah, the "arhitmetic if" from on lisp?
<makomo>
positive, zero, negative?
<hajovonta>
yes
<makomo>
mhm
<makomo>
that's a nice simple example i guess
<hajovonta>
yep, i knew i read it somewhere :)
<makomo>
:-)
<makomo>
however, i usually feel that trivial examples do a poor/bad job of explaining to people why something is useful
<makomo>
it's like the dreaded Animal and Shape examples of OOP
<makomo>
it drives me nuts
<makomo>
i.e. they're usually followed with stuff like "wooow, so what, why not just write 2 ifs, is that so hard?"
<makomo>
maybe at that point you should emphasize that it's about communicating intent and inventing a new vocabulary, so that the communication between people is "smoother"
<schweers>
It took me the longest time to really get macros (and there are of course still aspects of it which I don’t yet understand), but I really never understood the hostility some people seem to feel towards the idea.
<makomo>
i compare it to math a lot of times. mathematicians are great at inventing terminology and languages
<hajovonta>
Let over Lambda has some nice advanced macro examples, injections, captures, stuff like that. But I'm not sure if it can be simply demonstrated. A few weeks ago we had a discussion when we talked about closures, "they are not really necessary, I could solve all my problems without them so far"
<shrdlu68>
I think with-open-file, and macros like it, best demonstrate macros.
<makomo>
hajovonta: at that point give them an example which has closures as its canonical solutions
<schweers>
shrdlu68: maybe generally macros which prevent easy to make mistakes
<makomo>
for example, the good old "sorting with a comparator" problem
fikka has quit [Ping timeout: 245 seconds]
<beach>
schweers: I can explain that. If a person has spent a significant time with a language without macros like this, they will have had to produce a lot of boilerplate code. Now, if they discover that they could have avoided all that work if they had used a language with such macros, their mind can not accept this idea.
<makomo>
shrdlu68: that's a good example i'd say. it should also be mentioned along with the RAII idiom
<hajovonta>
what's that?
<hajovonta>
the RAII idiom
<schweers>
huh. so you mean I simply got lucky to know about macros before spending my career writing boilerplate code? I guess I have to think about this some more
<beach>
schweers: So the mind reacts by declaring that this feature is useless. And in fact, these people must declare it so that everyone else is convinced as well. If needed, they will go to great trouble, like ridiculing people for using macros, etc.
<makomo>
hajovonta: Resource Acquisition Is Initialization
<beach>
schweers: No, no.
<schweers>
beach: performance oriented vs perfection oriented
<beach>
Exactly.
<makomo>
for example, in C++ it's usually implemented as an object which acquires a resource in its ctor, and releases the resource in its dtor
<hajovonta>
i see
pierpal has quit [Read error: Connection reset by peer]
<makomo>
which means that, once the scope is left, the resource is released automatically
<makomo>
which then handles exceptiones "for free"
<makomo>
if an exception happens, the compiler makes sure that the dtor is called
<beach>
makomo: And if you want to send your object to some other module that might keep it, then you have to copy it, right?
<makomo>
an example of a resource might be a mutex (locking/unlocking)
<schweers>
beach: so you’re saying that people cannot bear the thought that they wasted their life performing RAII over and over again, simply because C++ has neither macros, nor unwind-protect. Sad state of affairs. Do you have a good antidote?
<shrdlu68>
Cognitive dissonance, he says.
<makomo>
beach: either that, or you could have just constructed it on the heap in the first place
<beach>
schweers: Carol Dweck has written a lot about it and she claims that it can be fixed, but the person must have the desire to do it, and that is already not so obvious.
<makomo>
or actually no, that's not strictly necessary
milanj has quit [Quit: This computer has gone to sleep]
<makomo>
yes, you could either copy it (if the semantics of the resource allow that)
<makomo>
or you could "move" it
<makomo>
i.e. rvalue references, std::move, etc.
<schweers>
If the person in question wants to fix it I don’t think there is a problem anymore
<beach>
makomo: But if you allocate it on the heap and then destroy it automatically, you are in trouble.
<makomo>
beach: of course. you would allocate it on the heap and preferrably use something like std::unique_ptr
jfrancis has joined #lisp
<beach>
makomo: Yes, and thereby introducing a few orders of magnitude slowdown compared to a language with uniform reference semantics.
<hajovonta>
i don't know enough c++, so I won't use that as a reference point :)
<makomo>
beach: hm i guess so. then std::move would perhaps be the best option
<beach>
makomo: I am always surprised by what C++ programmers are willing to accept, and they accept it thinking that it will speed things up.
damke_ has quit [Ping timeout: 244 seconds]
<beach>
I feel so sorry for them.
<schweers>
does anyone else find the direction that C++ has taken over the last few years quite undignifying?
scymtym has joined #lisp
samla has joined #lisp
<makomo>
beach: accepting the dynamic allocation you mean?
warweasle has joined #lisp
EvW1 has joined #lisp
<hajovonta>
what I also noticed is that almost always the #1 design consideration is that the code must be fast.
<schweers>
hajovonta: almost?
<beach>
makomo: Accepting the need to copy objects or introduce smart pointers, thereby slowing things down.
<hajovonta>
when implementing some new feature, I hear it all along "aha, and this way it can be made faster"
<makomo>
beach: there is a third option however, move semantics
<beach>
makomo: How does it work?
pierpal has joined #lisp
milanj has joined #lisp
<hajovonta>
when in fact the newly implemented code will take up only 0.1% of the total running time
flamebeard has quit []
<makomo>
beach: it's a language feature that came with C++11. basically it introduces rvalue references (along with the good old lvalue references) into the language, that allows one to overload functions depending on whether an object is a "temporary or not"
<hajovonta>
I cited the saying "Premature optimization is the root of all evil." and wrote it on the whiteboard
<makomo>
beach: that's a simplified explanation, the details are gory of course
samla has quit [Client Quit]
<hajovonta>
not everybody understood
pierpal has quit [Read error: Connection reset by peer]
<beach>
makomo: I bet. And of course, knowing whether an object is temporary or not is not something that the programmer should be concerned about. Or even could be, in the general case.
<makomo>
beach: so in short, you can for example, "move" a std::vector, without copying any memory. the move constructor just "steals" the memory of the original vector
jfrancis has quit [Ping timeout: 240 seconds]
<beach>
makomo: Thanks.
<makomo>
then of course you're left with "an object in an undefined but valid state" in the caller
<hajovonta>
I personally don't like to optimize the code :) I view it as a necessary bad thing
<schweers>
makomo: did you also get the impression that the explanations of what move semantics are, are exceptionally bad?
shangul has quit [Remote host closed the connection]
<makomo>
schweers: hm, i guess so. i spent a lot of time thinking/reading about it, "pieceing" together various bits of information
<hajovonta>
Let over Lambda has a few good pointers on how to speed up CL code
<beach>
I keep being surprised about the huge amount of trouble people are willing to go to in order to avoid Common Lisp.
<makomo>
because it's advertised as magic most of the time
<schweers>
magic may really be the right term. It is claimed to be awesome, but not explained
<schweers>
beach: me too
<makomo>
in reality, it's just another type within the language, and the ability to overload your functions based on it
pierpal has joined #lisp
<beach>
I think that observation shows how strong the psychological forces of the "performance oriented" people are.
<makomo>
i.e. the "rvalue reference to T" type
<hajovonta>
my colleague with lesser experience (few months) said "Lisp is the evil itself"
<makomo>
beach: haha :-)
<shrdlu68>
beach: I see "new" languages frequently on HN, claiming to solve old problems in some new way.
<beach>
shrdlu68: Let me guess. Common Lisp has already solved most of them.
<beach>
... decades ago.
<shrdlu68>
There is a special class of these "new" languages that seek to be "a better C".
<schweers>
He who does not study Lisp is doomed to re-invent it badly. He who does study it is doomed to watch other people re-invent it badly.
<schweers>
shrdlu68: which can probably be better described as: need only a very small runtime
<shrdlu68>
In fact the very first comment has something like "...no runtime overhead...".
<makomo>
beach: i just had a thought today. do you think the average programmer today would be more skilled/"smarter" had lisp been taught in every university ever?
<beach>
shrdlu68: It makes me tired to even think about. :(
<makomo>
or what if all of the resources and time that were spent on improving other languages were spent on improving lisp for example
<makomo>
i wonder where lisp would be today
fikka has joined #lisp
<schweers>
please stop, I’m close to crying
<makomo>
:^(
<beach>
makomo: Maybe. It would have to be done right. With the current way things are set up, it could very well backfire to teach Lisp.
<shrdlu68>
makomo: Nope. A lot of people do actually encounter Lisp in form of Scheme.
random9899 has joined #lisp
<makomo>
shrdlu68: not everywhere though. but imagine if it was taught *everywhere*
<schweers>
This may be seen as heresy, but I have come to think that scheme somehow misses the point
<makomo>
i wonder if it would improve anything
<makomo>
sadly i can't really perform this experiment
<beach>
makomo: Universities these days think that their mission is to satisify the desires of industry. The problem with that thinking is that they assume that industry knows what it needs.
<makomo>
beach: mhm :-(
<schweers>
when has industry ever known that? not just our industry, any industry?
<beach>
makomo: So the students get the impression that what industry requests is the good stuff. In such a setting, Lisp will not be accepted either way.
<shrdlu68>
makomo: It would probably only serve to fuel the many misconceptions about lisp. Have you noticed that almost everyone knows Lisp's reputation even before learning it?
<beach>
schweers: They haven't. The new thing is that Universities now believe it, or at least act as if.
Kundry_Wag has quit [Remote host closed the connection]
<shrdlu68>
"weird syntax", "AI", "too much memory", "interpreted", etc.
<makomo>
shrdlu68: yeah, another assumption in my hypothetical experiment is "assuming nobody heard of lisp before"
<makomo>
or at least didn't have any prejudices regarding it :-D
<beach>
makomo: First, my colleagues need to understand that the knowledge of what industry needs should be acquired at the universities.
<makomo>
beach: i agree
<hajovonta>
shrdlu68: "functional"
jmercouris has joined #lisp
<shrdlu68>
Heh, yeah.
<makomo>
i told my friend today about lisp's object system
<makomo>
"lisp has objects?"
<beach>
makomo: Then, teaching would have to be conducted in that spirit. Not "here is what you need to know in order to work in industry", but "here is what you need to know so that you can improve the situation where you will work".
<jmercouris>
shka: turned out to be some indentation package interferring
<schweers>
I remember that I was unhappy as a student about something or other (bad language, silly document format, something like that) on an assignment. My professor told me that this is training for use in industry. I remember thinking that it is the job of a university or college to teach students how things can be better instead of perpetuating the status quo
fikka has quit [Ping timeout: 240 seconds]
<makomo>
i told him that CLOS is the greatest object system he's ever seen
<schweers>
but alas, no such luck
<hajovonta>
yes lisp has objects and the object system is implemented on top of the language without performance loss
<beach>
schweers: Right on.
<hajovonta>
by means of macros
hjek has quit [Remote host closed the connection]
<makomo>
beach: yeah, it would have to be a complete change
<makomo>
then of course you tell him about MOP
<makomo>
i told him all of the hardcore stuff today, i don't even want to hold back
<shrdlu68>
If anything, this "preceding reputation" is probably the primary barrier to wide adoption, because people are otherwise surprisingly open to learning (about) "new" languages.
<beach>
Heh.
<beach>
shrdlu68: Hence "people are willing to go to a lot of trouble to avoid Common Lisp".
<schweers>
beach: or any lisp in general
<shrdlu68>
It's old and they've heard all about it.
<beach>
Indeed.
<makomo>
oh, right, today i wrote another lab exercise in lisp for a graphics course
<makomo>
and the same assistant that was there the last time was here today
<makomo>
he was excited to see me :-)
<hajovonta>
:)
<schweers>
hell, even editing source code in non-sexp based language is hell
<beach>
makomo: Excellent!
<makomo>
"wow, this is the first time i saw someone write this in lisp, amazing"
Kundry_Wag has joined #lisp
<makomo>
well, actually the second, since i wrote the last one in lisp too, but it's a saying :-)
uberman has joined #lisp
uberman has quit [Max SendQ exceeded]
<makomo>
imo, we need good/"hardcore" examples of stuff written in lisp, not just toy examples that try to convince people why macros are good
samla has joined #lisp
<makomo>
actually showing them a full example and that it's really possible is much better
uberman has joined #lisp
uberman has quit [Max SendQ exceeded]
<makomo>
hajovonta: that's why i think demonstrating stuff like the sorting network macros and similar is the best
fikka has joined #lisp
uberman has joined #lisp
<makomo>
stuff like with-gensym, once-only, etc. aren't as good because they're there as utilities
<makomo>
although once-only is awesome
<hajovonta>
yes, but i don't have infinite time for the demo, only 1 maybe 1.5 hours
<makomo>
1-1.5 hours?! holy :-)
<makomo>
i thought it would be more like 15 minutes
<makomo>
that's great, throw it all in
<makomo>
all the macros
<hajovonta>
and I need to demonstrate a lot more else before talking about macros
<makomo>
ah :^(
samla has quit [Remote host closed the connection]
<shrdlu68>
hajovonta: Show off slime.
<hajovonta>
you see, generalized booleans, setf-able places, higher order functions, closures, lexical scopes, etc
<makomo>
hajovonta: setf is a great example indeed
<hajovonta>
yep, along with SLIME stuff
<schweers>
oh. right. setf. how do people live without?
<makomo>
hajovonta: don't forget rotatef!
<hajovonta>
and then conditions+restarts, debugging running code
<makomo>
ah, you're going to show them conditions
<hajovonta>
yes, a little bit
<Fade>
thodg: I'm looking at the asd file for thot, and it depends on "bordeaux-queue", but that system is not illuminated by google, and it is not in quicklisp.
<hajovonta>
I plan to write some boring code which requires boilerplate, then show how to simplify it with macros
<schweers>
hajovonta: you’re showing this to collegues, right? do you use lisp at work?
m00natic has quit [Read error: Connection reset by peer]
<hajovonta>
and then at the end, I will show them the advanced examples we've been talking about: cl-ppcre, sorting networks, maybe advanced concepts
<shrdlu68>
hajovonta: Do it in such a way that they won't say "But I can do that with the preprocessor."
<makomo>
hajovonta: anaphoric macros also maybe? i'm not sure
<makomo>
maybe those are pushing it, idk. instead of aif you could showcase alexandria's when-let though
<hajovonta>
schweers: I used it for two years for automating manual system engineering work. Now I work with python, which is much less fun.
<makomo>
which isn't anaphoric, but does the same thing as aif
damke_ has joined #lisp
<shrdlu68>
Also, a great "standard library" that c++ is trying to catch up with.
uberman has quit [Quit: Leaving]
fikka has quit [Ping timeout: 256 seconds]
bbobb has joined #lisp
<schweers>
eww, why python? I guess you didn’t have much say in the matter?
<hajovonta>
schweers: we have an existing framework written in python, so that is a given
<hajovonta>
but it would be hard to find programmers who are capable of working with CL (or willing)
<hajovonta>
python or C programmers are also hard to find nowadays
<hajovonta>
but I guess this depends on how much you want to pay
<warweasle>
hajovonta: Really?
* warweasle
needs a raise.
<schweers>
wait, what?
<schweers>
how hard can it be to find programmers capable of working with python or C?
<makomo>
i thought about how nice it would be if he had something like make, but written in cl (and using cl for its makefiles, of course)
<makomo>
i'm not sure if asdf is as general as make?
<schweers>
people can learn how to program python in a day or two
<hajovonta>
schweers: first I have to familiarize myself with the problem domain, and because it's a big software that we provide a testing framework for, it can take up to 1.5-2 years.
<hajovonta>
schweers: we have a colleague who came from a bootcamp
<schweers>
agreed, but that is a different story than not being able to program in python.
<makomo>
beach: you talk about writing a paper on bootstrapping in your LOOP talk. has that been done? :-)
<schweers>
bootcamp?
PinealGlandOptic has joined #lisp
<makomo>
also, the videos from els 2018 aren't up yet :^(
buoyantair_ has joined #lisp
<makomo>
i hope they didn't forget about them
<beach>
makomo: No, I am still working on the bootstrapping paper.
fikka has joined #lisp
<hajovonta>
schweers: yes some few months and you are a software developer
<shrdlu68>
Nothing wrong with that, everyone starts somewhere and we can't all start at the same place. As long as he keeps learning and improving.
<schweers>
thats what we have colleges and universities for
<Fade>
thodg: thanks. I did google first!
<schweers>
and /hen/ you keep learning
buoyantair has quit [Ping timeout: 260 seconds]
<hajovonta>
schweers: some fundamental things are missing, like knowledge of networks, databases, etc. but otherwise we are lucky because the guy is good
<schweers>
I didn’t say he isn’t, but imagine what kind of work he could do if he were not denied a proper education?
<makomo>
beach: aha. could you let me know when you release it, if you can/remember (whether it's a draft or the full thing)? :-) i find the subject of bootstrapping very interesting (both from bootstrapping compilers to bootstrapping stuff like CLOS/MOP)
<hajovonta>
schweers: he was not denied but studied something else (psychology) and then realized that developing software is his dream.
<schweers>
okay, then it might just as well work
<schweers>
then I might want to retract my remarks
<shrdlu68>
schweers: Haha, you think universities are any better?
<schweers>
shrdlu68: they can be, but are not always so (I was not so lucky)
<shrdlu68>
I made a fizzbuzz challenge for interns and, of the two that tried my challenge, both had bugs in their code. University-educated.
<schweers>
so?
<beach>
makomo: I would like to make more progress on the SICL bootstrapping procedure first.
<makomo>
beach: of course, take your time. it'll be done when it's done :-)
<beach>
Exactly! :)
asarch has quit [Quit: Leaving]
Cymew has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
peccu4 has joined #lisp
Cymew has joined #lisp
mindCrime has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
peccu3 has quit [Ping timeout: 268 seconds]
kerrhau has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 260 seconds]
_cosmonaut_ has quit [Ping timeout: 245 seconds]
FreeBirdLjj has joined #lisp
aoh__ is now known as aoh
Kundry_Wag has quit [Ping timeout: 265 seconds]
samla has joined #lisp
aoh has quit [Changing host]
aoh has joined #lisp
Posterdati has joined #lisp
buoyantair has joined #lisp
fraya has quit [Remote host closed the connection]
samla has quit [Client Quit]
<TMA>
shrdlu68: i have given fizzbuzz as a question for hiring test. university graduates (masters degree in CS) most have had errors. it was the first time i have seen float based loop from one to 100
samla has joined #lisp
rippa has joined #lisp
varjag has joined #lisp
samla has quit [Remote host closed the connection]
* edgar-rft
has a masters degree in Couch Surfing
<shka>
TMA: interesting
FreeBirdLjj has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 244 seconds]
thodg has quit [Ping timeout: 240 seconds]
<shka>
TMA: what kind of error can be made in fizzbuzz?
<jmercouris>
TMA: which lang?
<schweers>
in an interview all sorts of errors can be made. not everyone interviews well
buoyantair has quit [Quit: Leaving]
<schweers>
Am I overlooking something or does the hyperspec not state what the default test function for MEMBER is?
<Bike>
this should be linked from more clhs pages, but it is not
<karlosz>
beach: the block bar block foo ex scymtym gave also returns 1 in clisp
<karlosz>
and i followed suite by making it return 1 in cleavir+clisp
<karlosz>
by inserting the lexical exits where they naturally belong
<karlosz>
for more data about what implementations do
<karlosz>
*lexical invalidations
<beach>
karlosz: OK, thanks for the info.
<schweers>
thanks Bike!
<TMA>
jmercouris: this was (at least nominally c or c++); I left the language choice to the candidates
<TMA>
shka: off by one (printing 0 to 99 instead of 1 to 100), omitting elses so that both the word and number gets printed, not testing for divisibility by 15 before checking for 3 and 5 while not omitting elses (so that Fizz is printed instead of FizzBuzz), I think there was a puts for printing numbers
FreeBirdLjj has joined #lisp
<schweers>
beach: regarding performance vs perfection oriented people: do you too get the impression that our field has this problem more than other fields do?
<beach>
schweers: I do have that impression, but I think it is wrong. Probably only based on the fact that I am not so knowledgeable in other fields.
<schweers>
maybe I should consult with my friend, who is a physicist.
<beach>
That's a good idea.
<beach>
You can also check with drmeister who is a chemist.
hajovonta has quit [Remote host closed the connection]
<TMA>
schweers: the hospital management requires measuring average time per "procedure" performed (where procedure is for example "chirurgically remove X") ... maybe there is performance pressure too
rpg has joined #lisp
buoyantair__ has joined #lisp
<schweers>
TMA: not what I meant, but yes, it is a problem. Then again, this is not the way things should be.
<beach>
TMA: Actually, it is unrelated. "performance oriented" is what I call what Carol Dweck calles "fixed mindset".
<beach>
TMA: ... and "perfection oriented" corresponds to a "growth mindset".
jfrancis has joined #lisp
jfrancis has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
jfrancis has joined #lisp
<shka>
beach: i read that essay
<shka>
i like your writings
<beach>
shka: Thanks. That one was quite a hit, it turns out.
<shka>
i guess
buoyantair_ has quit [Ping timeout: 260 seconds]
<shka>
others are also worth reading
<shka>
even the one about school uniforms :P
<schweers>
beach: you are in favor of school uniforms, right?
<beach>
shka: Glad you like the essays.
<beach>
schweers: I am, yes. Very much so.
<schweers>
did you wear one as a child?
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
<beach>
I did not, no. I didn't "discover" them until I spent a year in New Zealand much much later.
fikka has joined #lisp
<schweers>
I understand where you’re going with this essay, but I don’t think it solves the problem you are describing. Take a look at britain to see why.
elfmacs has quit [Ping timeout: 240 seconds]
<beach>
You may be right.
<schweers>
disclaimer: I am biased against school uniforms on the basis that I didn’t like them as a child.
<beach>
I see.
lumm_ has joined #lisp
<schweers>
but anyway, I think this is off-topic territory
<beach>
Definitely.
lumm_ is now known as lumm
lumm has quit [Client Quit]
lumm_ has joined #lisp
lumm_ is now known as lumm
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
terrorjack has quit [Remote host closed the connection]
pagnol has joined #lisp
terrorjack has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
palmtree_ has joined #lisp
Kundry_Wag has joined #lisp
EvW1 has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 248 seconds]
phenoble has quit [Quit: WeeChat 2.1-dev]
shrdlu68 has left #lisp [#lisp]
mathrick has quit [Ping timeout: 240 seconds]
nickenchuggets has quit [Quit: Leaving]
nickenchuggets has joined #lisp
schweers has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
koenig1 is now known as koenig
damke_ has joined #lisp
heisig has quit [Quit: Leaving]
mathrick has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
karswell has quit [Read error: Connection reset by peer]
sjl has joined #lisp
thodg has joined #lisp
fikka has joined #lisp
nowhereman_ has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
lumm_ has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
lumm has quit [Quit: lumm]
karlosz has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 256 seconds]
lumm_ has quit [Read error: Connection reset by peer]
lumm has joined #lisp
jmercouris has quit [Ping timeout: 276 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
thodg has quit [Read error: Connection reset by peer]
kmurphy4 has joined #lisp
kmurphy4 has quit [Max SendQ exceeded]
lumm has quit [Remote host closed the connection]
Naergon has quit [Ping timeout: 256 seconds]
pjb has joined #lisp
FreeBirdLjj has joined #lisp
kmurphy4 has joined #lisp
makomo has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
comborico1611 has joined #lisp
EvW has joined #lisp
Folkol has joined #lisp
Kundry_Wag has joined #lisp
fikka has joined #lisp
_leb has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
jasom has quit [Ping timeout: 255 seconds]
cmoore has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
EvW has quit [Read error: Connection reset by peer]
EvW has joined #lisp
palmtree_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
mflem has joined #lisp
fikka has joined #lisp
<akkad>
is there a more common solution to serializing say a hash object to a string, without resorting to so say json?
hhdave has quit [Ping timeout: 265 seconds]
<akkad>
e.g. leveldb requries strings for the value store. and was looking for a non-json approach
<jmercouris>
but provides no instruction on configuration...
aindilis has quit [Remote host closed the connection]
<akkad>
when running images remotely for any length of time, how do you do job control sort of stuff? e.g. redefine a function, and restart a thread running in the background?
aindilis has joined #lisp
cmoore is now known as clintm
clintm has quit [Changing host]
clintm has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
<jmercouris>
akkad: could use screen, or slime to hook into it
<akkad>
yeah, over slime/swank, in the repl proper, how do you do job control for threads.
<akkad>
the bt functions all seemed sort of cumbersome, and figured there must be a more job control like interface, that folks used for long running images
<jmercouris>
maybe you could even make a package, put it on quicklisp
Kundry_Wag has quit [Remote host closed the connection]
shwouchk has joined #lisp
fikka has joined #lisp
<innovati>
I'm not an emacs user, but I have heard emacs has lisp extensions and I'm _really_ curious about a scriptable editor…are there any good resources for getting started with emacs and elisp for people who are new to emacs?
igemnace has quit [Read error: Connection reset by peer]
<akkad>
jmercouris: sure, but not just because nih kicked in :P
<rpg>
innovati: Probably best to ask in #emacs - - you might specify that you are familiar with other lisps.
<innovati>
thanks <3
afterK has joined #lisp
afterK has joined #lisp
afterK has quit [Changing host]
fikka has quit [Ping timeout: 256 seconds]
<akkad>
specifically if it's palatal, dental or frontal
afterK has quit [Client Quit]
Kundry_Wag has joined #lisp
fikka has joined #lisp
hjek has quit [Ping timeout: 265 seconds]
fikka has quit [Ping timeout: 260 seconds]
shka_ has joined #lisp
PinealGlandOptic has quit [Quit: leaving]
SaganMan has joined #lisp
hjek has joined #lisp
<clintm>
Is there a way to get a list of the possible conditions that might be raised from a given function in slime? I'm confident there is not but I still find nuggets of hitherto unknown to me nuggets of utility, so I thought I'd ask.
<clintm>
oops... bad edit. oh well.
<Bike>
that's not statically determinable
<Bike>
and would be difficult to even get an approximation for
palmtree has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<clintm>
That'll teach me to not think deeper about my questions. Of course you're right.
herr_jth has joined #lisp
raynold has joined #lisp
sellout- has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
fikka has joined #lisp
lnostdal has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 268 seconds]
kmurphy4 has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<pierpal>
where is the "school uniform essay"?
buoyantair__ has quit [Ping timeout: 260 seconds]
lnostdal has joined #lisp
pierpal has quit [Quit: Poof]
stnutt has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
stnutt has joined #lisp
fikka has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
Naergon has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
EvW has quit [Remote host closed the connection]
EvW has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
MasouDa has quit [Ping timeout: 240 seconds]
comborico1611 has quit [Quit: Konversation terminated!]
beardio has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
lumm has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
lnostdal has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
lnostdal has joined #lisp
ted_wroclaw has joined #lisp
ealfonso has joined #lisp
<ealfonso>
I have a long-running service that continually adds elements to an array until it eventually runs out of memory and crashes. Is there a library that provides an abstraction to a data structure with a maximum in-memory capacity and the rest backed by disk?
Cymew has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
pagnol has quit [Read error: Connection reset by peer]
isBEKaml has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
<dlowe>
There could be with your help :)
<rpg>
clintm Bike: I think even if we had some structure like Java, we couldn't do much, because the set of standard conditions in the spec is minimal and weak.
<Bike>
it is pretty underwhelming
<rpg>
Even if you knew what set of conditions might be raised by a set of mathematical operations in SBCL, I doubt that would be at all predictive about what CCL or Allegro would do, for example.
fikka has quit [Ping timeout: 256 seconds]
<rpg>
I could imagine that given a small piece of code, and access to the SBCL source code, a sufficiently clever theorem-prover could compute a conservative over-approximation of the set of conditions that could be raised.
<rpg>
But anything very exact would be uncomputable (halting problem).
comborico1611 has joined #lisp
<ealfonso>
dlowe I guess this seems something similar to memory paging or caching, so I wasn't sure if there was something already available
jmercouris has quit [Ping timeout: 256 seconds]
17WABHCF5 has joined #lisp
<aeth>
ealfonso: There are ways to serialize to disk, so it shouldn't be too hard to choose one of them.
<aeth>
I'm not aware of something that does the missing step and automatically does this.
17WABHCF5 has quit [Client Quit]
<aeth>
Saving arbitrary objects to disk seems like the hard part, though.
_leb has joined #lisp
mindCrime has joined #lisp
clintm has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<ealfonso>
I was thinking of implementing this using a virtual array displaced to a real array of fixed capacity, with the real array periodically flushing to disk, and adding a custom handler for negative indices into the real array. I wonder if it's possible and efficient to handle a condition like this in a custom way : (aref (make-array 5) -1) => #<SB-INT:INVALID-ARRAY-INDEX-ERROR expected-type: "(INTEGER 0 (5))"datum: -1>.
fikka has joined #lisp
Kundry_Wag has quit [Read error: No route to host]
<rpg>
ealfonso: You can make your own condition, which is something like "item paged out of memory," and write a continue handler that would page it back in.
Kundry_Wag has joined #lisp
dented42 has joined #lisp
<rpg>
But it sounds like you need a notion of page or something, which sort of smells like you are reinventing virtual memory. Why doesn't OS VM solve this problem for you?
fikka has quit [Ping timeout: 260 seconds]
jmercouris has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
kerrhau has joined #lisp
kerrhau has joined #lisp
kerrhau has quit [Changing host]
Kundry_Wag has joined #lisp
<ealfonso>
rpg well, in my case the amount of memory grows continuously, and eventually the process always runs out of memory (including any additional swap space). but you're right that I could increase the amount of swap space without having to change anything else.
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
EvW1 has joined #lisp
<rpg>
ealfonso: Before trying this new data structure, unless you need it to be portable, I'd check with your lisp implementation to see if there's a way to make it smart about paging a data structure like this. Maybe there's some way to allocate it so that the implementation will handle it well. Or I wonder if you could just make a big array that's mapped on to some block-size of individual arrays, hoping that parts of the array that aren't being used will get paged out
<ealfonso>
in my particular case, I only care about the latest 'page' being in memory since it accounts for 99% of accesses, so for my use case I don't need to worry about paging, only about not crashing due to running out of memory by periodically flushing to disk or increasing virtual memory.
<rpg>
ealfonso: Right, but we need to make sure that the lisp implementation correctly discovers this pattern of memory access. So it would help to know if the implementation will, for example, page out parts of large in-memory data structures. If it *won't*, then it might help to do the trick I mentioned above.
fraya_ has joined #lisp
fikka has joined #lisp
comborico1611 has quit [Read error: Connection reset by peer]
<ealfonso>
rpg that's right. unless I implement it manually and manually flush to disk and only keep one page in memory (which would mean all other accesses outside of latest page would be a miss, which I think is OK in my case)
comborico1611_ has joined #lisp
jmercouris has quit [Ping timeout: 265 seconds]
dented42 has joined #lisp
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
karswell has joined #lisp
_leb has quit []
wheelsucker has joined #lisp
Mutex7 has joined #lisp
hhdave has joined #lisp
karlosz has quit [Ping timeout: 240 seconds]
hjek has quit [Quit: Leaving.]
Kundry_Wag has quit [Read error: No route to host]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
light2yellow has quit [Quit: light2yellow]
hhdave has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Remote host closed the connection]
fikka has joined #lisp
phenoble has quit [Quit: WeeChat 1.9.1]
krid has joined #lisp
jmercouris has joined #lisp
vlatkoB has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 248 seconds]
trittweiler_ has quit [Ping timeout: 248 seconds]
shka_ has quit [Ping timeout: 268 seconds]
kmurphy4 has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
d4ryus has joined #lisp
fikka has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
hjek has joined #lisp
hjek has quit [Client Quit]
fikka has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 240 seconds]
voidling has joined #lisp
fikka has joined #lisp
ZombieChicken has quit [Ping timeout: 250 seconds]
al-damiri has joined #lisp
warweasle_ has joined #lisp
warweasle_ has quit [Remote host closed the connection]
_leb has joined #lisp
_leb has quit [Client Quit]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<aeth>
This is huge. Nearly everything uses cl-opengl and cl-vulkan, the only alternative, is incomplete. Applications that wish to continue supporting 3D on macOS would need to port to Vulkan, cl-vulkan (or some other bindings), and use the MoltenVK library.
<aeth>
And this would have to be done before macOS 10.15 afaik
Kundry_Wag has quit [Remote host closed the connection]
scymtym has joined #lisp
Kundry_Wag has joined #lisp
karlosz has joined #lisp
dim has left #lisp ["Killed buffer"]
Kundry_Wag has quit [Ping timeout: 260 seconds]
kmurphy4 has quit [Remote host closed the connection]
warweasle has quit [Remote host closed the connection]
warweasle has joined #lisp
orivej has joined #lisp
vhost- has quit [Quit: WeeChat 2.1-dev]
Kundry_Wag has joined #lisp
dim has joined #lisp
herr_jth has quit [Remote host closed the connection]
<comborico1611_>
aeth: Thanks for important news.
ealfonso has quit [Ping timeout: 260 seconds]
<aeth>
A slight clarification: I'm not actually sure if deprecation means removal in macOS 10.15. It just means that it *could be* removed in macOS 10.15.
vhost- has joined #lisp
<Bike>
that's not actually slight
<rpg>
aeth: Aren't people saying that OpenGL *already* sucks on the Mac?
<aeth>
Bike: Well, you'd have to approach it the same way if you want to ensure continued macOS support.
<aeth>
That is, roughly a year to port to cl-vulkan and get MoltenVK working with CL.
<aeth>
rpg: The only thing worse than bad, 8-year-outdated support is nonexistent support
* rpg
remembers "The only thing worse than being talked about is *not* being talked about..."
<aeth>
rpg: I guess on the plus side, people will finally start abandoning OpenGL 3.3 or OpenGL 4.1 in favor of either Vulkan or newer versions of OpenGL. The macOS excuse will no longer exist and the older drivers/hardware for the other OSes are fading.
<rpg>
aeth: Seems weird, but I'm kind of a 2D guy, anyway! ;-) Have you checked in with #lispgames?
<aeth>
4.2 or 4.3 should be a fair assumption. 4.5 would support most.
<dxtr>
Is it possible to "append" (or would "merge" be the right word?) two hash tables?
nullniverse has joined #lisp
<Bike>
sure, but it's not built in or anything.
<dxtr>
hehe, alright
<Bike>
you can iterate over hash tables with a variety of mechanisms, such as maphash; the rest shouldn't be too hard depending on your desired semantics
<aeth>
The only real issue would be what to do when two things share the same key.
<dxtr>
Question #2: Are hash tables passed as copies? What I'm basically wondering is that if I modify a hash table within a function will that affect the caller too?
<Bike>
no, they are not copied.
<dxtr>
Alright
<Bike>
lisp does not do implicit copying except of a few objects that are immutable anyway.
<dxtr>
That's what I figured - just wanted to confirm :)
<dxtr>
Oh, so if I modify *anything* within a function that affects the caller too? This is an area I haven't really thought about
<dxtr>
I always try to make everything immutable but this time I'm considering if non-mutability is simply easier
<dxtr>
err
<dxtr>
s/non-//
<rpg>
dxtr: most things *are* immutable, but there are things like list structures (if you use nconc or the like), arrays (if you modify their contents), etc.
mindCrime has quit [Ping timeout: 245 seconds]
<dxtr>
Alright
<rpg>
e.g. if you change a variable from one string to another, it doesn't harm the original string. It's only if you modify the string's contents.
pierpa has joined #lisp
<aeth>
There is an alexandria:copy-hash-table if you want to copy one
ZombieChicken has joined #lisp
varjag has quit [Ping timeout: 268 seconds]
epony has quit [Quit: QUIT]
<dxtr>
neat
<aeth>
What's the best way to ensure sb-ext:*derive-function-types* when building an executable with SBCL but not during development?
<Bike>
ensure ... is bound when?
TCZ has joined #lisp
<aeth>
sb-ext:*derive-function-types* is normally NIL, and should normally be NIL, but when compiling an executable for SBCL for applications using my framework, it should be T. It makes SBCL assume that functions won't be redefined to change the function types, which gives more power to the compiler. i.e. Optimizations, compile-time warnings/errors, etc.
TCZ has quit [Read error: Connection reset by peer]
<aeth>
This is desirable for a standalone executable.
Arcaelyx has joined #lisp
<rpg>
aeth: One way to do it would be to bind that variable around the build process for the executable. You could do that relatively easily, I think, if you were using Fare's ASDF "bundle" stuff.
<rpg>
That said, I've never used that stuff myself, except to run tests, so I'm not at all familiar with its ins and outs.
<aeth>
Oh, there is a slight complication in that what I'm doing is an engine/framework thing, so the ultimate executable will be for a system other than the systems that I am writing.
Bike has quit [Ping timeout: 260 seconds]
nullniverse has quit [Ping timeout: 248 seconds]
fraya has quit [Remote host closed the connection]
fraya_ has quit [Remote host closed the connection]
LiamH has quit [Quit: Leaving.]
nopf has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
cmoore has joined #lisp
markoong has quit [Ping timeout: 245 seconds]
markoong has joined #lisp
dtornabene has joined #lisp
mrcom_ has quit [Quit: Leaving]
mrcom has joined #lisp
cmoore has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
TCZ has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
kmurphy4 has quit [Quit: kmurphy4]
Kundry_Wag has quit [Ping timeout: 256 seconds]
kmurphy4 has joined #lisp
wheelsucker has quit [Ping timeout: 256 seconds]
robotoad has quit [Quit: robotoad]
Domaldel has quit [Quit: Leaving]
svillemot has quit [Ping timeout: 256 seconds]
comborico1611_ has quit [Quit: Konversation terminated!]
robotoad has joined #lisp
markoong has quit [Ping timeout: 264 seconds]
kerrhau has quit [Ping timeout: 265 seconds]
kmurphy4 has quit [Quit: kmurphy4]
jfrancis_ has joined #lisp
fyodost has joined #lisp
jfrancis has quit [Ping timeout: 260 seconds]
Kaisyu has joined #lisp
<Xach>
the quicklisp build server has a failed hard drive. i'll get a new one in the next few days and hope to be back annoying people with build failures by the weekend.