stepnem_ has quit [Read error: Connection reset by peer]
stepnem has joined #lisp
Volt_ has joined #lisp
bitmappe_ has joined #lisp
bitmapper has quit [Ping timeout: 265 seconds]
bitmappe_ has quit []
bitmapper has joined #lisp
permagreen has joined #lisp
karlosz has quit [Quit: karlosz]
<pjb>
seok: indeed, the database gives: Six-Per-Em Space
<pjb>
seok: you must have copy-pasted text from some typeset unicode.
<pjb>
seok: type M-x whitespace-mode RET
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
patlv has joined #lisp
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 268 seconds]
Fare has joined #lisp
slyrus has joined #lisp
slyrus__ has quit [Ping timeout: 240 seconds]
pfdietz94 has joined #lisp
patlv has quit [Ping timeout: 265 seconds]
bitmapper has quit [Ping timeout: 268 seconds]
pfdietz94 has quit [Remote host closed the connection]
ahungry has joined #lisp
stepnem has quit [Read error: Connection reset by peer]
stepnem has joined #lisp
pfdietz2 has joined #lisp
igemnace has quit [Ping timeout: 240 seconds]
dented42 has joined #lisp
EvW1 has quit [Ping timeout: 264 seconds]
igemnace has joined #lisp
Oladon has quit [Quit: Leaving.]
atgreen_ has joined #lisp
enrio has joined #lisp
atgreen has quit [Ping timeout: 240 seconds]
stepnem has quit [Ping timeout: 246 seconds]
stepnem has joined #lisp
goose121 has joined #lisp
dgtlcmo has quit [Quit: leaving]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
atgreen_ has quit [Ping timeout: 240 seconds]
semz has quit [Ping timeout: 245 seconds]
dgtlcmo has joined #lisp
akoana has quit [Read error: Connection reset by peer]
akoana has joined #lisp
ebzzry has quit [Ping timeout: 240 seconds]
dgtlcmo has quit [Quit: leaving]
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
FreeBirdLjj has joined #lisp
dented42 has joined #lisp
<eschatologist>
Seriously, trying to recreate a LispM keyboard because you think it’ll be more efficient for writing Lisp than modern keyboard layouts?
<eschatologist>
If you think keyboard layout is having a noticeable effect on your development, my guess is you’re doing something pretty wrong.
<eschatologist>
Also I’m pretty sure the LispM stuff was never actually designed for more than minimal ergonomic improvement.
<eschatologist>
Hall-effect switches sound neat, but they’re not really all that great as keyboards.
<no-defun-allowed>
And the modifier keys look nice as a bilingual writer (well, really I just write α, β and λ but it's enough to be annoying).
<eschatologist>
This whole “Symbolics keyboards are the Holy Grail!” or “what’s slowing me down is not having a Space Cadet keyboard!” thing is silly.
<White_Flame>
all you need is a good compose key setup
<eschatologist>
There are Mac keyboards at least (like the Matias stuff) that show the option key mapping so you can type a lot of that directly.
goose121 has quit [Remote host closed the connection]
stepnem has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
FreeBirdLjj has quit [Ping timeout: 276 seconds]
stepnem has joined #lisp
Frobozz has joined #lisp
stepnem has quit [Ping timeout: 240 seconds]
stepnem has joined #lisp
xkapastel has joined #lisp
stepnem has quit [Ping timeout: 240 seconds]
stepnem has joined #lisp
slyrus has quit [Ping timeout: 265 seconds]
<dmiles>
is there a quasiquote reader for lisp?
<no-defun-allowed>
fare-quasiquote?
<dmiles>
like #/python/ .... /#
orivej has quit [Ping timeout: 265 seconds]
<dmiles>
ok will check
<no-defun-allowed>
Oh, uum
<no-defun-allowed>
Not as in `(stuff ,goes here)?
<dmiles>
i can for instance make one.. but been nice if a someone already reserved be a hash-character
<dmiles>
i can make one.. but been nice if a someone already reserved me a hash-character
<no-defun-allowed>
What would it do?
<dmiles>
#/ LangName / passed to (calls-quasi-reader LangName this content as a string/stream ) until /#
<dmiles>
so that you may embed other language sytaxes without using up a reader macro for each language
<dmiles>
Quasi quotation allows for embedding (long) strings using the syntax of an external language (e.g., HTML, SQL) in Lisp text and syntax-aware embedding of Lisp sysmbols in this syntax. At the same time, quasi quotation provides an alternative to represent long strings in Lisp.
<no-defun-allowed>
I have a #{ }# reader somewhere, which I used for a DSL; #/foo/ looks like a regular expression.
<dmiles>
i was thinkin #{ was used already ..
<dmiles>
awesoem if not
<no-defun-allowed>
Not to my knowledge.
raghavgururajan has joined #lisp
<dmiles>
#{|Syntax||Quotation|}#
<dmiles>
is what i will use then :)
<dmiles>
#{|(html Name Address)|| <tr><td>Name<td>Address</tr> |}#
<dmiles>
if <tr><td>1<td>2</tr> is read
<dmiles>
oops sorry .. thats next phase i should stick with first phase
<dmiles>
you could even do that though youd (run-in-lanuage (strin (read)) (string (read)).. consume until #}
<dmiles>
actualyl i dont like that idea of mine... i'd just read off the first symbol.. then pass the rest like youpassed the rest
<dmiles>
#{|Some Whatnot| Some text }#
<dmiles>
since perhaps a language might enjoy |
<dmiles>
}# is more unique
ahungry has quit [Remote host closed the connection]
<White_Flame>
the way I do it, #{ reads a symbol via the common-lisp reader, then switches to that other named-readtable. That inner table needs to have } or }# or whatever to call pop-readtable. Theoretically, it can have whatever EOF character it wants to trip that
<White_Flame>
so if it alerady uses something similar, you can choose whatever suits that language best. It just won't visually nest as nicely
<dmiles>
of course since i love to compicate things i let there terminating sequnce be the inversions of a list of printing chars following first symbol read
<dmiles>
#{Some-Syntax ?666> Some text <666?}
<dmiles>
unspoken requiremnt there is that the the <Space> happens on both ends
<dmiles>
since cant do: #{Some-Syntax ?666>Some text<666?}
gravicappa has joined #lisp
space_otter has quit [Remote host closed the connection]
<dmiles>
#{|Some-Syntax| >--|-{} Some text {}--|-< }
<White_Flame>
dmiles: one could argue the proper reflection should be >--|-{} to }{-|-->
* White_Flame
triggers every OCD ever
<dmiles>
dont feel bad! i been practicing in messages to myself :)
gabiruh_ has joined #lisp
<dmiles>
#{|where to stick it| ╭∩╮ to da man ╭∩╮} vs seeign what mirrors there might be for ò益ó well tryi8ng to miror ¯\_(ツ)_/¯
gabiruh has quit [Ping timeout: 264 seconds]
<dmiles>
imagining spending a whole day creating the utimate text "mirroring" librarty
<no-defun-allowed>
White_Flame: the solution is to mirror characters, eg p <-> q
<dmiles>
well cerain sequnces have to be pre-ordained
<dmiles>
like that makes apearance shapes like "{}" "<>" "`'"
<dmiles>
even ツ will need ot be mirrored as ツ
<dmiles>
yet singlely "{" changes
<dmiles>
knowing if one really wants to do this all this and have it work for everyone they have to probly loosen up what mirrored text was.. we'd want to accept both {}--|-< and }{-|-->
<dmiles>
and even }{--|->
<dmiles>
oopsy i realy meant {}-|--<
<dmiles>
at least its a fun way to handle it.. and even solves the in/out issue
xkapastel has quit [Quit: Connection closed for inactivity]
<dmiles>
#{|where to stick it| ╭∩╮ to da man named ╭∩╮ #.(get-username) ╭∩╮ on computer ╭∩╮ #.(get-host) }
<dmiles>
if there was a outer language reader
<dmiles>
in practice everone will proably pick a single character anyways
zaquest has quit [Remote host closed the connection]
<no-defun-allowed>
Maybe I have forgotten if I asked before, but are there any things I have to know before starting development of an object persistence library?
<dmiles>
fiddlerwoaroof: oh neat
vlatkoB has joined #lisp
gravicappa has quit [Ping timeout: 265 seconds]
Fare has joined #lisp
<beach>
no-defun-allowed: You need to decide about semantics. And you may want to compare it to Clobber.
space_otter has joined #lisp
<beach>
no-defun-allowed: One danger is to store objects by slots. Then, if the class changes, your "database" is useless.
gravicappa has joined #lisp
<beach>
no-defun-allowed: I developed Clobber to get around such problems in so-called "prevalence" libraries.
pfdietz2 has quit [Ping timeout: 260 seconds]
<beach>
I fix that problem by making Clobber totally log based. Each transaction creates a log entry, and you load the entire log into a fresh Common Lisp image, which will then create an image "similar" to the previous one.
<beach>
Clobber consists of less than 300 lines of Common Lisp code.
<fiddlerwoaroof>
Where is SDF's issue tracker?
<fiddlerwoaroof>
ASDF's, that is
<no-defun-allowed>
Hmm, alright, I'll go see.
gravicappa has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
My plan to handle that is to store the list of slots we would be assuming we have otherwise, and compare those to the current class definition. If not, we update-instance-for-redefined-class and might write that back.
<beach>
That might work. However, the existence of a slot is an implementation detail, and you may not want to save implementation details in the data base. I consider the interface to a class to be the initialization arguments and the slot accessors.
<no-defun-allowed>
Fair enough.
dddddd has quit [Read error: Connection reset by peer]
<beach>
You could also study how we save ASTs in Cleavir. It uses exactly this idea.
<beach>
And you should consider the consequences of your implementation choice on the programming style. As I think I have told you before, if you can have several "copies" of an object, then you end up programming as in C++.
<no-defun-allowed>
Yeah, we have discussed it earlier in #sicl.
<beach>
Clobber fixes this problem by staying out of the way during normal execution, and by creating an entirely fresh object graph when the log is loaded into a fresh Common Lisp image.
<fiddlerwoaroof>
What generates new log entries?
<beach>
fiddlerwoaroof: I forget the details, but there is a function for logging a transaction.
<no-defun-allowed>
That's not far off the plan here either, but our system might contain "overlapping" graphs and so a weak hash-table will probably ensure that those overlapping parts are the same objects.
<beach>
The Clobber repository contains two demos.
<fiddlerwoaroof>
Cool, I'll look at them. This sounds like something which is often called the "lambda architecture"
<fiddlerwoaroof>
A couple of my coworkers like to design their data stores this way
retropikzel has joined #lisp
<beach>
Oh, OK.
<beach>
I just wrote Clobber as a reaction to all the complicated stuff I heard and read about.
<beach>
I am no expert in databases or persistent stores.
<fiddlerwoaroof>
Yeah, I think it's a good way to go when the cost of replaying the log isn't too high
<beach>
What I really want is universal persistence (in case someone missed that). :)
<beach>
fiddlerwoaroof: Exactly. And as it turns out, people overestimate the cost of replaying.
<beach>
I guess they consider their organizations to be more important than they really are.
<beach>
When our university bought Oracle for a huge amount of money to handle student data, I did a lecture in my programming class, showing that 100 years of student data would fit in the main memory of the laptop I used for my slides.
<beach>
And, after laptop memories double in size every few years.
<beach>
s/after//
<fiddlerwoaroof>
Yeah, I maintain a service at work where our schema update strategy is to replay something like 30GB of events into our database and that takes something like 3 days
<beach>
Impressive.
<fiddlerwoaroof>
But we can do this mostly without downtime because either the changes are only additive or we play this into an empty database and cut over atomically
<beach>
Still, there is either something wrong with current database technology, or at least with the way people use it.
<beach>
But since I am not an expert, I usually avoid getting into details.
<White_Flame>
fiddlerwoaroof: I was not aware of vernacular either. nice to know
<fiddlerwoaroof>
I think I happened upon it because it's written by the person who wrote the Spinneret HTML generator
<White_Flame>
seems like it assumes the actual language grammar is external, which is fine for me to plug into, because I'm tackling grammar
<no-defun-allowed>
I'm not counting too carefully, but my dataset would likely not fit in memory. Maybe I should guesstimate harder.
<fiddlerwoaroof>
no-defun-allowed: just remember that 1TB of memory is already possible in high-end consumer computers (e.g. the new Mac Pro)
<White_Flame>
use moar swap
<fiddlerwoaroof>
And SSDs are close enough to memory speeds that falling back to the disk isn't as painful as it once was
zaquest has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
<no-defun-allowed>
fiddlerwoaroof: Well, Heroku has about 1/2000 of that and I've heard SBCL acts up with heaps larger than something like 64GB
Oladon has quit [Quit: Leaving.]
<fiddlerwoaroof>
no-defun-allowed: there's a reason I don't use Heroku :)
<no-defun-allowed>
Sure.
<no-defun-allowed>
I think I would be much more broke than before if I rented a server for more than five seconds with 1TB of primary memory though.
<fiddlerwoaroof>
Yeah, my point is just that memory is getting cheap pretty fast and the gap between memory and disk (and network, for that matter), is closing rapidly
<ggole>
GCing massive heaps is an interesting problem
<no-defun-allowed>
Alright, I'm not going to disagree with you, but I have to play with what I have now, which is probably going to be two magnitudes smaller than that.
FreeBirdLjj has joined #lisp
Fare has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
And we just got out of a price fixing thing, that made memory quite a bit more expensive, for no reason other than cause the two big manufacturers could.
<fiddlerwoaroof>
ggole: I don't know much about it, but I'd think some combination of region-based allocators and gcs would be the best way to go
<ggole>
Yeah, there are some systems like that. Erlang has thread-local heaps, for instance.
<ggole>
You couldn't implement a Lisp that way without major surgery though
<no-defun-allowed>
My first design probably will use a mark-during-sweep collector as described in one of Queinnec's papers - I haven't touched this stuff outside Racket's plai/gc2 but I know I need something there.
<beach>
ggole: I have a design for a thing like that for SICL, but it has not been tested in real life yet.
<beach>
But it combines thread-local heaps with a parallel and concurrent global collector.
<beach>
I have great hopes for it.
FreeBirdLjj has quit [Ping timeout: 268 seconds]
<beach>
Processors are going to have plenty of cores, so we might as well use some of them for garbage collection.
nika has joined #lisp
<ggole>
beach: do you have a reasonable description lying around?
<beach>
I sure do; metamodular.com/SICL/sicl-specification.pdf
<ggole>
Thanks, I'll take a look
<beach>
chapter 23.
<beach>
And appendix C.
<no-defun-allowed>
Can't say I know how running an incremental GC with a program that uses the database frequently would go on spinning disks. Hopefully it won't have to.
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
igemnace has quit [Quit: WeeChat 2.6]
orivej has joined #lisp
<beach>
ggole: I apologize for the lengthy description (50 pages or so in total), but the specification is mainly meant as a support for my bad memory, and not so much for others to read.
vlatkoB_ has joined #lisp
nadare has joined #lisp
<ggole>
That's fine, I can skim
MichaelRaskin has left #lisp [#lisp]
vlatkoB has quit [Ping timeout: 245 seconds]
dented42 has joined #lisp
shka_ has joined #lisp
akoana has left #lisp ["Leaving"]
<ggole>
Hmm. The bit on the write barrier says that it might move an object (and anything reachable from it) from a nursery into the global heap. How does that work if another thread is reading (or mutating) one of those objects?
<beach>
Objects in a thread-local heap can not be referenced by another thread.
<ggole>
So the write barrier is only run on the same thread that would be doing any such mutation
<beach>
Right.
<ggole>
I see.
rippa has joined #lisp
xuxuru has joined #lisp
xuxuru has quit [Client Quit]
xuxuru has joined #lisp
Codaraxis_ has quit [Read error: Connection reset by peer]
Codaraxis_ has joined #lisp
Codaraxis_ has quit [Ping timeout: 245 seconds]
ebzzry has quit [Read error: Connection reset by peer]
Codaraxis_ has joined #lisp
stepnem_ has joined #lisp
stepnem has quit [Ping timeout: 240 seconds]
<phoe>
good morninnnnng
<no-defun-allowed>
Good morning phoe
stepnem_ has quit [Ping timeout: 265 seconds]
nowhere_man has quit [Ping timeout: 268 seconds]
stepnem has joined #lisp
_whitelogger has joined #lisp
iskander has quit [Ping timeout: 276 seconds]
gareppa has joined #lisp
iskander has joined #lisp
Volt_ has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
cosimone has joined #lisp
count3rmeasure has quit [Quit: Leaving]
atgreen_ has joined #lisp
gareppa has quit [Quit: Leaving]
raghavgururajan has quit [Remote host closed the connection]
fanta1 has joined #lisp
Codaraxis_ has quit [Read error: Connection reset by peer]
Codaraxis_ has joined #lisp
<thijso>
morning, everyone
cosimone has quit [Ping timeout: 250 seconds]
cosimone has joined #lisp
nika has quit []
jonatack has quit [Quit: jonatack]
raghavgururajan has joined #lisp
<thijso>
This summer I somehow ended up on a page about Android app development with CL (maybe this one: https://lights-of-holiness.eu/blog/ECL-QML-Android.htm) and being bored I thought I'd try to realize the idea I had for an app myself. I had investigated this (using CL for android dev) years before, but at the time gave up due to nothing really working yet. This time, after quite some struggles I actually managed
<thijso>
to build and run one of the examples in EQL5-Android. So I started. Long story short, it's doable, but too much fiddly stuff with version combinations and dependencies exist. That's why I made this side-project: https://github.com/thijs/android-ecl-bootstrap
<thijso>
It's very much inspired and built upon other people's work, most notably ECL and EQL5-Android.
<thijso>
It provides (I think) an easy and reproducable way to start building your own apps for Android using CL
<thijso>
It's by no means finished, and I'm very open to suggestions and improvements.
<thijso>
But as it stands currently, if you're on a linux and have docker installed, you should be able to build the example app with just a few commands.
<thijso>
So where would be a good place to advertise this exists? I'd like more people to start working on this stuff, so I don't have to figure out all the gotchas myself... ;)
xuxuru has quit [Quit: xuxuru]
raghavgururajan has quit [Remote host closed the connection]
enrioog has joined #lisp
<phoe>
thijso: /r/lisp and /r/common_lisp on reddit and the Lisp Discord server
<phoe>
#lisp and #ecl and #lispcafe are also good
enrio has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
X-Scale has quit [Ping timeout: 265 seconds]
cosimone has quit [Quit: Terminated!]
cosimone has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
Fare has joined #lisp
retropikzel has quit [Remote host closed the connection]
X-Scale has joined #lisp
Fare has quit [Quit: Leaving]
papachan has joined #lisp
vms14 has joined #lisp
pfdietz92 has joined #lisp
Codaraxis_ has quit [Read error: Connection reset by peer]
Codaraxis_ has joined #lisp
jonatack has joined #lisp
bitmapper has joined #lisp
atgreen_ has quit [Remote host closed the connection]
atgreen_ has joined #lisp
gravicappa has joined #lisp
<pfdietz92>
thijso: interesting!
<thijso>
pfdietz92: yeah, I hope so. My aim is to make it as easy as possible to get up and running so that more people will maybe try it out and give feedback.
EvW has joined #lisp
FreeBirdLjj has joined #lisp
vms14 has quit [Remote host closed the connection]
clothespin has quit [Ping timeout: 252 seconds]
FreeBirdLjj has quit [Ping timeout: 264 seconds]
gravicappa has quit [Ping timeout: 245 seconds]
lucasb has joined #lisp
gravicappa has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
gdsg has joined #lisp
Codaraxis_ has quit [Read error: Connection reset by peer]
Codaraxis_ has joined #lisp
stepnem has quit [Ping timeout: 265 seconds]
FreeBirdLjj has joined #lisp
stepnem has joined #lisp
retropikzel has joined #lisp
stepnem has quit [Ping timeout: 268 seconds]
stepnem has joined #lisp
enrioog has quit [Quit: Leaving]
ebzzry has joined #lisp
gareppa has joined #lisp
grewal has joined #lisp
Codaraxis_ has quit [Read error: Connection reset by peer]
Codaraxis_ has joined #lisp
varjag has joined #lisp
enrio has joined #lisp
papachan has quit [Ping timeout: 265 seconds]
varjag has quit [Ping timeout: 268 seconds]
dddddd has joined #lisp
oni-on-ion has joined #lisp
gxt has joined #lisp
gravicappa has quit [Ping timeout: 268 seconds]
Inline__ has joined #lisp
Inline has quit [Ping timeout: 264 seconds]
retropikzel has left #lisp ["Leaving"]
jonatack has quit [Ping timeout: 276 seconds]
igemnace has joined #lisp
atgreen_ has quit [Ping timeout: 250 seconds]
varjag has joined #lisp
salinasc has joined #lisp
varjag has quit [Ping timeout: 245 seconds]
mulk has quit [Ping timeout: 240 seconds]
salinasc has quit [Quit: Konversation terminated!]
salinasc has joined #lisp
salinasc has quit [Client Quit]
salinasc has joined #lisp
gravicappa has joined #lisp
dale has joined #lisp
mathrick has quit [Remote host closed the connection]
varjag has joined #lisp
mathrick has joined #lisp
jonatack has joined #lisp
karswell has joined #lisp
nowhere_man has joined #lisp
<beach>
Am I reading the hash-table dictionary of the Common Lisp HyperSpec right in that there are parameters for controlling when and how a hash table grows, but there is nothing about when to shrink it?
<beach>
And if I am right, is the implementation still allowed to shrink it when the number of entries is small compared to the current size?
<Shinmera>
Indeed it's not specified that it would ever shrink.
<beach>
Thanks for confirming.
<Shinmera>
I'm not sure whether it's expressly allowed or forbidden that it will shrink, but typical hash table usage patterns don't see shrinkage very often to begin with.
<pfdietz92>
Those values are only advisory anyway.
<beach>
I guess that's true.
<beach>
OK, thanks.
<pfdietz92>
I mostly ignore them.
<beach>
As a user, I definitely ignore them.
<beach>
But now, I have to implement the protocol.
<Shinmera>
I've only ever explicitly specified test and size.
<beach>
Different question (that may have been discussed, but I can't remember any consensus): I often have a system that implements standard stuff, like a hash table in this case.
<beach>
I would like to build it in two different ways, possibly with two different ASDF systems, but without too much code duplication.
<beach>
One system should assume that the system is built in the native implementation.
<beach>
The other one should build it so that the package definition shadows standard symbols.
<beach>
What is a good way of doing thsi?
Jeanne-Kamikaze has joined #lisp
<Shinmera>
Can the two systems be loaded at the same time?
<beach>
That is not a requirement.
cosimone has quit [Quit: Quit.]
<beach>
The second way is when I want to test the code in a host implementation, and I don't want to clobber the host code.
<pfdietz92>
Now, if you want to EXTEND the protocol, that leads to all sorts of interesting things. Synchronization, weakness, specification of hash functions, new equality predicates.
<Shinmera>
beach: In the first case you could create a nickname for the target package you want to have your definitions land in, and in the latter case create a new package with that name directly.
<Shinmera>
you define these two behaviours in separate files and load one or the other depending on the system
cosimone has joined #lisp
<beach>
Shinmera: Can you give an example?
<beach>
... a small one.
<beach>
Maybe I understand.
<beach>
So two different package definitions.
<Shinmera>
I'm writing an example.
<beach>
The native one just does (:use #:common-lisp).
<beach>
Oh, OK.
<pfdietz92>
That would be my preference also.
<Shinmera>
I'm seeing another solution now that I think I prefer
<Shinmera>
The other idea would have been to use separate files, one file of which adds the custom-hash-table nickname to cl, and the other of which defines a custom-hash-table package.
fanta1 has quit [Quit: fanta1]
<Shinmera>
I suppose you could still do this without conditionals if you have access to the PLN protocol to add nicknames programmatically.
<Shinmera>
And then just split the behaviour across files again as before.
<pfdietz92>
I wonder if it's possible to virtualize packages and the reader in some way. Read this form in a virtual lisp whose package naming does not affect the lisp it's embedded in.
<pfdietz92>
Well, obviously possible, but conveniently so.
<beach>
Shinmera: OK, I failed to communicate a requirement that is not fulfilled in your proposal. The code must look "natural", i.e. there should be no package prefixes on CL symbols.
<Shinmera>
Oh. How would you do that without also accidentally interning things into the CL package then?
<Shinmera>
Since that would require you to be in-package CL
<beach>
In the host, the hash-table package would shadow the Common Lisp symbols.
<beach>
The COMMON-LISP package already has the symbols both in the host and in the target.
<Shinmera>
pfdietz92: I suppose you could get a long way there by reading things in a package that shadows CL & co. for another package that substitutes operations for your own that virtualise them.
<Shinmera>
*that uses PLNs to shadow
<Shinmera>
beach: I see.
<beach>
But I think I see how. The native system has a component for creating a package with no shadowing. Just (:USE #:CL).
<beach>
The host system has a different component that creates a package with the same name, but it shadows the relevant symbols.
<beach>
The only problem is the duplication of the list of components in the two ASDF systems.
<Shinmera>
you could define a custom system class to embed that, but it would probably cost you more lines than it saves.
<Shinmera>
not to mention the headache of understanding it :)
<beach>
Yeah.
<beach>
Indeed.
<beach>
I'll try this out and maybe later I can figure out how to avoid the duplication.
<beach>
Thanks for all the help.
<beach>
Hmm, there is a problem. If I have one or more "extension systems" depend on some "base system", say for different implementations of hash tables, the extension systems should not have to "know" which base system has been chosen. More thinking is requirde.
nowhere_man has quit [Ping timeout: 252 seconds]
<beach>
required, even.
<phoe>
so you have a M-N relationship, it seems
<beach>
I hope not.
<phoe>
a multitude of base systems with another multitude of extensions
<phoe>
unless there is some way to form a M-1-N relationship
<beach>
Nope, every extension applies with the same code to every base.
<phoe>
Hm. Let's suppose you have BASE-FOO, BASE-BAR, BASE-BAZ. That is possible, correct?
<phoe>
And you have EXT-A, EXT-B, EXT-C.
clothespin has joined #lisp
<phoe>
And I understand that every extension can apply to every base.
<beach>
By the way, this way of organizing packages is very interesting, and CLIM requires it, namely that the protocol symbols are the only symbols in the main package (as in CL or CLIM), and the implementation packages :USE the main package. That way, random symbols in the implementation packages are local.
<beach>
phoe: I have BASE-FOO-NATIVE and BASE-FOO-HOST.
<beach>
That's it.
<beach>
The only difference is how the package is defined.
<beach>
So the code in the extensions is identical, no matter what base is chosen.
<phoe>
beach: OK, understood.
<phoe>
The way I see it, you could define a "protocol system" named BASE that requires either BASE-NATIVE or BASE-HOST as an implementation.
<beach>
Now, does ASDF guarantee the order between the :DEPENDS-ON systems?
<phoe>
And extensions then extend BASE rather than either of the two "implementing systems".
<phoe>
That would solve the M-N relationship I was thinking of.
<beach>
phoe: How do you define a system that requires either one system or the another one, and how is that determined?
<beach>
phoe: I suspect we are talking past each other.
<beach>
I need to think about this problem some more. Maybe i will come up with a concrete, more detailed, example.
<phoe>
beach: :DEPENDS-ON is out of question, I think, since it means that the system depends on *all* of the mentioned dependencies, whereas we want a logical "or" - either one or the other.
Codaraxis_ has quit [Read error: Connection reset by peer]
Codaraxis_ has joined #lisp
<phoe>
If I understand you correctly, then a good situation would be (defsystem :base :depends-on-either (:base-native :base-host) ...)
orivej has quit [Ping timeout: 264 seconds]
<beach>
But I would need a mechanism to choose between the two.
<beach>
But yes, that would fix the problem.
<beach>
I guess some special variable and a #. would fix it.
<phoe>
What would actually mark the choice as made? Loading either of the two implementing ASDF systems?
<beach>
Or a reader conditional.
<beach>
Yes, I would like to do either (asdf:load-system :bla-native) or (asdf:load-system :bla-host)
<phoe>
what about (defsystem my-system :depends-on (:base :base-native) ...) then
<beach>
I don't see how that works.
<phoe>
oh wait, I misunderstood you
<phoe>
nevermind
Jeanne-Kamikaze has quit [Quit: Leaving]
salinasc has quit [Ping timeout: 240 seconds]
lemoinem has quit [Killed (adams.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
hiroaki has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
synaps3 has joined #lisp
synaps3 has quit [Changing host]
synaps3 has joined #lisp
EvW1 has joined #lisp
<phoe>
What is the current location for the fresh ANSI-TESTS?
jonatack has quit [Read error: Connection reset by peer]
jonatack_ has joined #lisp
<pfdietz92>
I keep tweaking my own copy, mostly for new flavors of random testing.
<phoe>
well, that's a pain
jonatack_ has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
<phoe>
I'm trying to set up Travis CI for CCL and I'll want a test suite to run that isn't CCL's own ANSI-TEST suite, since it's outdated and needs to have CCL-specific tests factored out of it
<phoe>
in theory I could run both clnet's and your copies, nothing's wrong in running some tests twice other than for wasted time
clothespin has quit [Ping timeout: 276 seconds]
orivej has quit [Ping timeout: 240 seconds]
Rhedd has joined #lisp
random-nick has quit [Remote host closed the connection]
<pjb>
beach: but I thought it was a good idea that build the CL package by importing the symbols it will export (so it wouldn't have interned any other symbol). In that case, in both situation you can have your hash-table code in the same CL.HASH-TABLE package. The only difference, is that for the native case, you would add a system depending on the host system, adding a file to do this importing/re-exporting.
<pjb>
beach: (and yes, I'd advocate for multiple asd files instead of using conditionals, notably if it's #+/#-, for setting *features* is a hassle, and work normally only at read-time).
Codaraxis_ has quit [Read error: Connection reset by peer]
synaps3 has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
salinasc has joined #lisp
atgreen_ has joined #lisp
hiroaki has quit [Ping timeout: 252 seconds]
<pfdietz92>
I would not recommend taking my copy. I let control go for some years, and the current version needs to have some unfortunate changes removed.
<pfdietz92>
(logical pathnames, what?)
<phoe>
pfdietz92: OK. If you consider it worth your time, maybe you could backport some new tests of yours over to the clnet copy.
<pfdietz92>
Overall I need to separate out the random testing part.
<phoe>
I see
gabiruh_ has quit [Quit: ZNC - 1.6.0 - http://znc.in]
atgreen_ has quit [Ping timeout: 276 seconds]
gabiruh has joined #lisp
<pfdietz92>
There are really three parts: the original "small" tests against the standard, the differential compiler testing part with large random forms, and a set of type propagation tests ("RTP" test). All under ansi-tests, but otherwise not much overlap.
<pfdietz92>
Most recent SBCL bug finds are from improvements to the last part.
hdasch has quit [Read error: Connection reset by peer]
<pfdietz92>
There's also some mutation-based test generation sitting around somewhere, which I have never released.
<pfdietz92>
This was: troll through quicklisp and various public lisps packages for code fragments, randomly splice and mutate these, then see if the compiler can be made to blow up. This was for SBCL, where the compiler is never supposed to throw an error.
hdasch has joined #lisp
Nomenclatura has joined #lisp
shifty has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
patlv has joined #lisp
enrio has quit [Ping timeout: 245 seconds]
hiroaki has joined #lisp
patlv has quit [Ping timeout: 240 seconds]
hiroaki has quit [Read error: Connection reset by peer]
hiroaki has joined #lisp
salinasc has quit [Ping timeout: 246 seconds]
vlatkoB_ has quit [Remote host closed the connection]
patlv has joined #lisp
karswell has quit [Read error: No route to host]
cosimone has quit [Quit: Quit.]
EvW1 has quit [Ping timeout: 276 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
patlv has quit [Ping timeout: 276 seconds]
rgherdt has joined #lisp
bitmapper has quit [Remote host closed the connection]
bitmapper has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
bitmapper has quit [Ping timeout: 268 seconds]
bitmapper has joined #lisp
mathrick has quit [Ping timeout: 264 seconds]
ggole has quit [Quit: Leaving]
cosimone has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
madage has quit [Remote host closed the connection]
random-nick has joined #lisp
madage has joined #lisp
patlv has joined #lisp
<jackdaniel>
logical pathnames are removed for some time already
<jackdaniel>
just saying
<jackdaniel>
pfdietz92: ^
<pfdietz92>
Cool, thanks :)
<pfdietz92>
If I've been told that before and forgotten, I blame age.
grumble is now known as grumboo
<jackdaniel>
you've been ;)
shka_ has quit [Ping timeout: 268 seconds]
patlv has quit [Quit: Leaving]
Inline__ has quit [Quit: Leaving]
Inline has joined #lisp
dilated_dinosaur has joined #lisp
akoana has joined #lisp
zxcvz has quit [Quit: Leaving]
random-nick has quit [Ping timeout: 264 seconds]
gareppa has joined #lisp
varjag has quit [Ping timeout: 246 seconds]
Nomenclatura has quit [Quit: q]
sjl has quit [Quit: WeeChat 2.2-dev]
akoana has left #lisp ["Leaving"]
ebzzry has quit [Read error: Connection reset by peer]
gareppa has quit [Quit: Leaving]
manualcrank has joined #lisp
saravia has joined #lisp
ebzzry has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
seok has quit [Remote host closed the connection]
rgherdt has quit [Ping timeout: 252 seconds]
monokrom has quit [Remote host closed the connection]