shangul has quit [Remote host closed the connection]
mangul has joined #lisp
<no-defun-allowed>
It's the Structure and Interpretation of Computer Programs theme slowed down (which in turn, is Jesu, Joy of Man's Desiring by Bach played on a crappy synthesizer).
mangul has quit [Ping timeout: 272 seconds]
<edgar-rft>
but is it the original Jesus?
zaquest has quit [Quit: Leaving]
Fare has quit [Ping timeout: 246 seconds]
mangul has joined #lisp
Misha_B has joined #lisp
Fare has joined #lisp
gko has joined #lisp
ntqz has quit [Ping timeout: 260 seconds]
EvW1 has joined #lisp
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
toorevitimirp has joined #lisp
PuercoPop has joined #lisp
bitmapper has quit [Ping timeout: 260 seconds]
Fare has quit [Ping timeout: 258 seconds]
Nilby has joined #lisp
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
dddddd has quit [Ping timeout: 256 seconds]
Fare has joined #lisp
mono has joined #lisp
lxbarbosa has joined #lisp
rand_t has quit [Quit: rand_t]
monokrom has quit [Ping timeout: 256 seconds]
Josh_2 has quit [Ping timeout: 264 seconds]
EvW1 has quit [Ping timeout: 244 seconds]
efm has joined #lisp
efm has quit [Client Quit]
brutalist has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]
ebzzry has joined #lisp
brutalist has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
ebzzry has quit [Quit: WeeChat 2.3]
turona has quit [Ping timeout: 260 seconds]
turona has joined #lisp
SGASAU` has quit [Quit: ERC (IRC client for Emacs 26.3)]
SGASAU has joined #lisp
Oladon has quit [Quit: Leaving.]
djuber has joined #lisp
<beach>
Good morning everyone!
Oladon has joined #lisp
<markasoftware>
How do you pass information lexically from a macro to a sub-macro?
<pjb>
what is a sub-macro?
<pjb>
markasoftware: the macro has full control on what it expands to.
<markasoftware>
i'm writing a trivial test framework. I have a (define-suite) macro and (define-test) macro.
<Bike>
if by sub macro you mean a macro being expanded to, you can use macrolet or symbol-macrolet
<markasoftware>
the tests go inside of the suite. I want to access the name passed as an argument to define-suite
<markasoftware>
so (define-suite (:name "My test suite") ... (define-test (:name "My unit test") (do-the-test)))
djuber has quit [Ping timeout: 246 seconds]
<markasoftware>
and I want define-test's expansion to know about the name of the suite.
<Bike>
right, so you could expand that to like (symbol-macrolet ((+suite-name+ "My test suite")) (define-test ...)) and then have define-test macroexpand '+suite-name+ to get the name.
<markasoftware>
so i should use macrolet or symbol-macrolet?
<markasoftware>
i guess that makes sense
<pjb>
it would be better.
<pjb>
(define-suite (:name "Your test suite") (define-test (:name "Your unit test") (do-the-test)) )
<markasoftware>
but then define-test will not know it at compile time.
<pjb>
and (defmacro define-test (…) (error "define-test must be embedded in a define-suite"))
<markasoftware>
i guess you are right, with macroexpnad Bike
<markasoftware>
i have to admit i'm not fond of using macroexpand outside of debugging but i guess it does the job!
<markasoftware>
i might just do what pjb suggested
<pjb>
markasoftware: Bike macro is overengineered. You don't need the symbol-macrolet and macroexpand, because name is known! You can use it in the expansion defmacro foo with just: ,name
|3b| has joined #lisp
EvW has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
ArthurStrong has quit [Quit: leaving]
<Oladon>
So... I'm still having issues. Turns out it has nothing to do with Postmodern. I've distilled a minimal test case, and if anyone's willing to take a look, I'd be most grateful. https://pastebin.com/SNLfgtUG
<Oladon>
For those who weren't here earlier: I can't get this setf method definition to run for a specific class. I suspect user error.
oldtopman has joined #lisp
oldtopman has joined #lisp
zaquest has joined #lisp
<Bike>
when you say case 1 doesn't work, what do you mean?
<Bike>
for an instance of user, that is
<Oladon>
Bike: It doesn't seem to get called at all, judging by the lack of format output
<Bike>
what do you get from (compute-applicable-methods #'(setf password) "string" some-user1)?
<Bike>
oh, well, wait, i missed that user1 has a password slot
<Bike>
since you define a slot, a writer method is defined
<Bike>
the writer is called preferentially to your method
<Oladon>
Ahhh
<Oladon>
Changing :accessor to :reader makes case 1 get called.
<Oladon>
Bike: You're a genius. Thank you. :)
<Bike>
no problem
<Bike>
your method doesn't set the actual password slot, tho
<Oladon>
Yeah, I don't actually want it to
<Oladon>
It's basically a pretend slot
<Oladon>
(... so why have a reader? That's a good question, Oladon...)
<Bike>
why have a slot at all?
<Oladon>
I thought I had to in order to be able to setf it
<Oladon>
Is that not the case?
<Bike>
nope.
<Oladon>
Huh.
<Oladon>
Well then.
<Oladon>
Even better! :)
<Bike>
i mean, you defined your method on the has-secure-password1 class, right? and it doesn't have a password slot.
<Oladon>
true...
<Oladon>
I guess I just assumed (quite incorrectly) that it'd be upset if the object it was called with didn't have that slot, regardless of whence it came
<Bike>
(setf (foo ...) nv) expands into (funcall #'(setf foo) nv ...) unless there's a setf expander. you can define setf functions that don't do anything remotely slot-like.
<Bike>
setf doesn't actually know about clos at all, so to speak.
<Oladon>
Yeah, that's fair -- i.e. setf car
<Bike>
mhm.
<Bike>
it's just that when you do :accessor foo, defclass defines a (setf foo) function for you.
<Oladon>
Makes total sense. I'm guessing that your compute-applicable-methods would've shown me that (though I can't quite get it to work)
<Bike>
oh, i screwed it up. (compute-applicable-methods #'(setf password) (list "string" some-user1))
<Oladon>
Ahh, thanks. There it is.
<Oladon>
(#<SB-MOP:STANDARD-WRITER-METHOD
ArthurStrong has joined #lisp
<Oladon>
Is there a convention for denoting a "ghost slot" like password is being here? I'm inclined to have it reflected somewhere...
<Oladon>
But maybe that's just a silly inclination :)(
<Oladon>
:) rather.
<Bike>
in the class definition itself? not really
<Oladon>
Aight. I may just toss a nod in the docstring.
<Bike>
that would probably be good
<Oladon>
I am very grateful for your assistance. This has been stymieing me for a few days now.
<Bike>
it's no trouble
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
narimiran has joined #lisp
narimiran has quit [Client Quit]
westerns has left #lisp [#lisp]
RukiSama has joined #lisp
mangul has quit [Ping timeout: 246 seconds]
asarch has joined #lisp
mangul has joined #lisp
mmkarakaya has joined #lisp
Bike has quit [Quit: Lost terminal]
EvW has quit [Ping timeout: 260 seconds]
mangul has quit [Remote host closed the connection]
mangul has joined #lisp
yankM has quit [Ping timeout: 260 seconds]
sauvin has joined #lisp
Oladon has quit [Quit: Leaving.]
oxum has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
gravicappa has joined #lisp
nullniverse has joined #lisp
mathrick has quit [Ping timeout: 265 seconds]
mmkarakaya has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
mangul has quit [Quit: Leaving]
leo_song has quit [Remote host closed the connection]
mangul has joined #lisp
leo_song has joined #lisp
lxbarbosa has quit [Ping timeout: 240 seconds]
shka_ has joined #lisp
<asarch>
Is there a shortcut for: (if (get-the-content data) (get-the-content data) "")?
leo_song has quit [Remote host closed the connection]
<no-defun-allowed>
(or (get-the-content data) "")
brutalist has joined #lisp
rixard has quit [Ping timeout: 264 seconds]
leo_song has joined #lisp
brutalist has quit [Read error: Connection reset by peer]
leo_song has quit [Remote host closed the connection]
heisig has joined #lisp
mangul has quit [Ping timeout: 256 seconds]
<asarch>
Thank you!
<asarch>
Thank you very much! :-)
<phoe>
also prevents double evaluation™
<beach>
That is not great style though.
<beach>
Presumably, GET-THE-CONTENT either returns some content, or NIL if there is no content.
<beach>
So GET-CONTENT should not be considered as returning a Boolean vaule.
<beach>
value
<no-defun-allowed>
True, the data shouldn't be treated as a generalised Boolean.
<no-defun-allowed>
(content, rather)
<beach>
As a consequence, it should not be the TEST of an IF, nor part of an OR.
<beach>
So the good way of doing it is (let ((content-or-nil (get-content...))) (if (null content-or-nil) "" content-or-nil))
<beach>
Again, page 13 of the LUV slides by Norvig and Pitman.
<beach>
You can see this issue easily if you consider the following scenario: In the future, you decide that GET-CONTENT will return :NOT-PRESENT instead of NIL there is no content. You should not have to transform all of your code to accommodate such a minor change.
<asarch>
Or (get-content-p)?
<beach>
In fact, you should probably have a function (say) REAL-CONTENT-P so that your code becomes (let ((potential-content (get-content ...))) (if (real-content-p potential-content) potential-content ""))
<asarch>
I see
<beach>
That way, you have a single place in your code where the default value is known.
leo_song has joined #lisp
* asarch
takes notes...
<beach>
asarch: These are elementary software-engineering considerations. Not particularly related to Common Lisp.
<shka_>
also you never know if nil is supposed to be empty list, false or 'nothing'
<beach>
And GET-CONTENT and REAL-CONTENT-P should be part of the same module.
<phoe>
that's alexandria:when-let and alexandria:if-let
<phoe>
beach: asarch: ^
<aeth>
A minor note, but if you have control over naming GET-THE-CONTENT... As far as naming goes, the CL standard has a GET- in a few places, but that's either an oversight or a legacy API kept for compatibility. Generally, where other languages getFoo or get_foo, CL just says foo, which can be done because it's a Lisp-2.
<beach>
phoe: Are you saying that we put this bad practice in a library?
<aeth>
Well, really a Lisp-6 or so, and namespace #3 is important here. Types are a separate namespace. No need to say (get-foo ...) when the type foo is in a separate namespace
<shka_>
in general, i would like to use nil as empty value, but this works only if result is not a list
<shka_>
so not always
<shka_>
so not pretty
leo_song has quit [Ping timeout: 272 seconds]
<shka_>
oh, there is yet another way to handle this
<shka_>
you can return the secondary value from get-the-content
<shka_>
OR
<beach>
Indeed, that's another possibility.
<shka_>
signal condition if there is no content
pve has joined #lisp
<shka_>
which sometimes is ok
<beach>
That's yet another one.
<shka_>
and sometimes not
<beach>
It's a bit verbose to handle, but it works.
<shka_>
anyway, returning nil also works, just not always
<phoe>
beach: yes
<shka_>
for instance position returns nil if position couldn't be found
<shka_>
same for member
<beach>
shka_: It works as long as get-content and real-content-p are in agreement, which they can be if they are part of the same module.
<shka_>
right
<shka_>
which also means that it makes the difference only if the said functionality is exported
terpri has quit [Remote host closed the connection]
<asarch>
Thank you guys!
<asarch>
Thank you very much! :-)
terpri has joined #lisp
yangby has joined #lisp
yangby has quit [Client Quit]
asarch has quit [Quit: Leaving]
wxie has quit [Ping timeout: 272 seconds]
rgherdt has joined #lisp
oxum has quit [Remote host closed the connection]
leo_song has joined #lisp
mangul has joined #lisp
leo_song has quit [Remote host closed the connection]
sbodin has joined #lisp
sbodin__ has quit [Read error: Connection reset by peer]
<phoe>
> equalp descends hash-tables by first comparing the count of entries and the :test function; if those are the same, it compares the keys of the tables using the :test function and then the values of the matching keys using equalp recursively.
orivej has joined #lisp
<phoe>
this last part sounds like NIL should be returned instead
<no-defun-allowed>
What implementation is that? None of the ones I have on me return T there.
sdumi has quit [Read error: Connection reset by peer]
<no-defun-allowed>
But I don't think that's expected, no.
sdumi has joined #lisp
<phoe>
recentmost ECL
<phoe>
lisp koans are so funnnn
<shka_>
well, this seems wrong
* phoe
files an ECL issue
<phoe>
okie then, let's keep on testing
<beach>
phoe: What you are doing is a great service to the community.
nika has joined #lisp
dalz has quit [Remote host closed the connection]
<phoe>
beach: I'm glad that I can serve the Lisp community while exhibiting raw and uncensored rage at the current state of the Lisp Koans
<beach>
That's an excellent combination, yes.
orivej has quit [Ping timeout: 256 seconds]
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
ayuce has joined #lisp
gko has quit [Ping timeout: 240 seconds]
mangul has quit [Remote host closed the connection]
ralt has joined #lisp
<lukego>
Is there an easy way to have QuickLisp apply patches and/or hotfixes to packages at installation time?
<shka_>
nope
<shka_>
as far as i know
<phoe>
lukego: nope, submit patches upstream.
<shka_>
you can stick your patched libs into local projects
<phoe>
or what shka_ says
<phoe>
what kind of patches are you thinking of?
<lukego>
phoe: well here the issue is that a patch has already gone upstream and I want to cherry-pick it into my own env, with minimum disturbance. I'm worried about taking the whole master branch of package FOO in case that cuases compat issues with quicklisp default versions of other packages
<phoe>
lukego: you don't need to take the whole master branch; you can checkout the version that got included into Quicklisp, and cherry-pick the patch on top of that
<shka_>
well, it always worked for me
<phoe>
you have all of git at your disposal, you can use it for your satisfaction
shangul has joined #lisp
<lukego>
phoe: maybe, but my build system is heavily automated, and a manual step like pinning one package is going to hurt me sooner or later
<lukego>
I mean I _can_ pin it but then I'll have to start being more disciplined about upgrading to newer quicklisp distros
frgo has quit [Remote host closed the connection]
<lukego>
maybe I should consider a radically different strategy though e.g. pulling every project into a local git repo where I can just hack 'em directly.
<lukego>
maybe my quicklisp local-projects dir could be a git repo with all relevant projects referenced as submodules
<Nilby>
lukego: I just either patch it on dists/quicklisp/software directly or link my own patched copy in local-projects depending on the complexity of the patch. The former get overwitten on upgrade, the latter is more obvious.
ayuce has quit [Remote host closed the connection]
random-nick has joined #lisp
<Nilby>
Of course, another option, perhaps more reliable, is to include the patch in your software.
<lukego>
I don't want any local state that's not "checked in" somewhere. I've been using Nix to snapshot Quicklisp distros. Maybe I should instead snapshot Quicklisp into Git submodules.
<lukego>
but then I also want to be able to run automated builds with all dependencies captured, which brings me back to nix, and I don't want to maintain two separate packaging systems
rixard has joined #lisp
<lukego>
Include it with my software? That sounds nice but I'm not sure how -- I'm getting an error at load time on McCLIM so the patch would have to be applied somewhere within ASDF I suppose
SGASAU` has quit [Quit: ERC (IRC client for Emacs 26.3)]
<Nilby>
(defun broken-package:broken-function ...
igemnace has joined #lisp
<lukego>
doesn't really help me when the error occurs while loading broken-package though -- can't patch it before the package exists
SGASAU has joined #lisp
<lukego>
would be fine if the error was occurring later though
sdumi has quit [Ping timeout: 272 seconds]
<Nilby>
I do use git submodules, they're a little annoying, but it could make a reproducible build.
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
sdumi has joined #lisp
sdumi has quit [Ping timeout: 256 seconds]
sdumi has joined #lisp
TMA has quit [Ping timeout: 272 seconds]
oxum has joined #lisp
<lukego>
I'm looking at the snapshot of Quicklisp packages that I get from ql2nix. This is the metadata that I have now. Question is how to extend this to support patches/modifications to packages in a simple way. https://gist.github.com/lukego/a27c16302dfc8122a4bcab0a652618ad
mangul has joined #lisp
shangul has quit [Ping timeout: 260 seconds]
rozenglass1 has quit [Ping timeout: 246 seconds]
<lukego>
So it looks like already now my (mostly inherited) build is downloading the sources ahead of time for quicklisp, so I should be able to patch them easily there
liberliver has quit [Ping timeout: 272 seconds]
rozenglass1 has joined #lisp
<lukego>
might be easier if my canonical sources were git repos instead of tarballs but I'm not sure how that fits with quicklisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
gko has joined #lisp
<MichaelRaskin>
lukego: you can look at how the overrides that are already there are implemented
<lukego>
MichaelRaskin: which overrides do you mean?
<MichaelRaskin>
Well, this might be more a #nixos conversation, but Nixpkgs not only generates stuff from Quicklisp, but also has a file with overrides, e.g. for passing foreign libraries
<lukego>
hm... I should check nixpkgs... this is an out-of-tree tool called ql2nix that I found on github but that was quite some time ago and maybe nixpkgs has moved forwards. thanks for the prod
<Nilby>
Interesting. That looks like it basicly ingests and replicates quicklisp.
mood has quit [Ping timeout: 256 seconds]
mood has joined #lisp
<lukego>
Nilby: Yeah. First it runs quicklisp with some ASDF hooks to record all of the sources that are downloaded. Then it snapshots all of those sources. Then for actual build it preinstalls the sources and runs Quicklisp again to load them.
* lukego
takes it to #nixos
<MichaelRaskin>
Nilby: The main point is that Nix the package manager wants to checksum all the downloads itself. And if you want the foreign binaries to be provided by Nix, it is convenient to also translate Quicklisp data into Nix.
<Nilby>
Impressive. I didn't know anything else did that.
<phoe>
Nilby: it's not very hard, given that Quicklisp is basically a collection of text files and zips + a lisp client
cosimone has joined #lisp
<MichaelRaskin>
It is slightly more annoying now that we do not believe what Quicklisp reports about dependencies, but still not hard.
<Nilby>
With lisp packages integrated into a system package system it opens up the possibilities of lisp packages having non-lisp dependencies which get automatically installed.
<lukego>
Handy thing with Nix is that the snapshot can include all dependencies e.g. X libs, opengl libs, fonts, etc. Then that whole environment can be replicated onto another machine with one command. So even though you have to fight a bit extra to get stuff installed you mostly only have to do that fight once.
<Nilby>
Nice.
* Nilby
is considering trying a Nix install.
rand_t has joined #lisp
<lukego>
I like it but it's a bit of a religion unto itself and it does make you reluctant to do things the easy/imperative way which is a mixed bag
yankM has joined #lisp
karlosz has quit [Quit: karlosz]
<MichaelRaskin>
At some point some HPC people did a reimplementation of Nix in Guile called Guix. They have some benefits and drawbacks (but for full-system use their stricter-than-Debian stance on non-free software starts having an impact)
msk has joined #lisp
<heisig>
MichaelRaskin: A lot of HPC software is proprietary, yet available on Guix. And, Guix has s-expressions :)
<Nilby>
I'm afraid I'll like Guix too much if I try it. And there's only 86400±2 secs/day.
<lukego>
I'm also afraid of looking at Guix because my universe is already too complicated by options today. despite having been put onto Nix by a Guile maintainer (wingo) in the first place.
devrtz has joined #lisp
<lukego>
but I note that my current setup is really inadequate in that all the packages are read-only which makes it hard to contribute to them and pull patches. Just adding patches will probably be too much effort. Have to think about what's best. Too bad the metadata I pull from quicklisp is only for tarballs and not git repos or else I'd be tempted to go down the "create git repo of submodules" route.
<MichaelRaskin>
You could clone quicklisp-projects repo
<lukego>
oh interesting. so quicklisp is pulling from version control and then converting to tarballs.
<MichaelRaskin>
Mostly
<Nilby>
For most cases at least.
<lukego>
I also wonder if it's really needed to do this asdf-instrumentation to see which dependencies Quicklisp pulls in, when that information should be available in simple parsable text files in the quicklisp repo to begin with?
<lukego>
mostly is good enough. I don' timagine I'll want to contribute to many projects that aren't under version control anyway
<MichaelRaskin>
Most of the time it _is_ available in Quicklusp repo
<MichaelRaskin>
Quicklisp is built in a way that is a bit too resilient, so some releases can contain broken dependency information and still work with the Quicklisp client
devrtz has joined #lisp
devrtz has quit [Client Quit]
devrtz has joined #lisp
<lukego>
do we have a recording of Xach's fantastic ECLM talk on Quicklisp way back when? I really need to learn how it works internally better
<MichaelRaskin>
If ASDF fails to find something, Quicklisp can handle this condition and download the package (so the QL metadata can be almost completely broken and things will still work)
<MichaelRaskin>
And this fallback is necessary for local-projects stuff to work transparently
<lukego>
I'm not yet making a proper distinction in my mind between the quicklisp client verses the backend and which state/files belong to which
<lukego>
maybe quicklisp upstream could generate a .nix file even?
<Nilby>
It looks like the client + asdf could have enough for the nix file. But that gist looked like it had quicklisp + ultralisp in it?
<lukego>
Just quicklisp client. haven't looked at ultralisp
zooey has quit [Ping timeout: 240 seconds]
zooey has joined #lisp
random-nick has quit [Quit: quit]
ralt has quit [Quit: Connection closed for inactivity]
<lukego>
the way I've handled dependencies in the recent past has been a bit extreme. that's to make each one a git subtree with full history. that way you can e.g. 'git bisect' to find individual commits in new releases that have caused you trouble. you can also commit fixes directly and upstream them asynchronously. maybe should take the same approach here, hm.
<lukego>
it means you have one big monorepo incuding all the dependencies and all of their history, which has downsides, but it is pretty simple
<lukego>
I suppose that I could keep my own code in a separate repo so that the big monorepl is only for the dependencies and not something I'm interacting with all day every day
<Nilby>
I like the monorepo approach too.
ayuce has quit [Remote host closed the connection]
<lukego>
ql2monorepl...
<lukego>
repo
<lukego>
then I could also track updates. instead of just replacing all the releases with new releases I would add merge commits that each pull in the changes to each package
Fare has joined #lisp
<lukego>
And to follow the "simple but extreme" approach I'd probably just include every package in the quicklisp distro
<lukego>
or be lazy and take the ones that have git repositories to start with
<Bike>
phoe: define-method-combination also does a key before rest kind of thing. i forgot because nobody uses define-method-combination
<Nilby>
That would be great! I think Xach's production stuff sort of does that.
<phoe>
Bike: you are right
ayuce has joined #lisp
<lukego>
So the data I need for a proof of concept is a set of <package-name,git-url,commit> tuples telling me which version of each package to import and from where.
<lukego>
oh and I recall now that the guy who invented git-subtree invented something new now that probably I should familiarize myself with in case it's better
random-nick has joined #lisp
<lukego>
Could even build up an interesting history by tagging each quicklisp release
<lukego>
maybe the git commit tree would look like
<lukego>
* Merge Quicklisp release yyyy-mm-dd
<lukego>
*** Fix bug in package foo
<lukego>
*** Add feature in package foo
<lukego>
** Merge package foo commit abcdefg
<lukego>
** Merge package bar commit defghij
<lukego>
...
<Nilby>
It sounds very useful. I wonder how much space it would take up.
<lukego>
Xach is a class act. reading the script he wrote for his 2015 talk. extremely luxurious way to get information
msk has quit [Read error: Connection reset by peer]
msk has joined #lisp
<lukego>
So from quicklisp-projects I can get the name of each project and its source repository. where can I find the information to choose which git commit to pull?
<lukego>
i.e. the git commit corresponding with the version in a given quicklisp release
<Xach>
lukego: that info is not currently available. it's something i want to make.
<Nilby>
Yes, mostly. But some repo's have special non-git or even non-vcs download methods.
<Xach>
lukego: i'd like to gather and share provenance info but i don't do it yet. stuff like "commit <sha> was fetched from <upstream> on <timestamp>"
<Xach>
or "tarball file with <sha> was fetched from <url> on <timestamp>"
<Xach>
if i wait long enough i don't have to figure out the right syntax for darcs
jw4 has quit [Read error: Connection reset by peer]
<Xach>
lukego: you can approximate the checkout by going from the date on the dist
LISPer has joined #lisp
jw4 has joined #lisp
<Nilby>
I would really wish there was some way to have every .asd file, so I could work on a UI.
<Xach>
Nilby: that is not very difficult!
<LISPer>
I am using ACL 32bit version...but needs 64bit compiler..but have no budget to buy ACL 64bit...Is there good alternative compiler for 64bit windows ?
SGASAU has quit [Remote host closed the connection]
<phoe>
LISPer: SBCL, CCL
<Nilby>
Xach: I would be most grateful if you could point me toward the way?
SGASAU has joined #lisp
<Xach>
Nilby: do you mean within quicklisp?
<Nilby>
Xach: Any way that you think might be proper to collect the .asd's
<Xach>
Nilby: right - i mean, the system files provided by quicklisp?
<Nilby>
Right now I could just go through the projects dirs, is that what you would reccommend?
<p_l>
LISPer: ECL will also work in 64bit code and might be of interest on windows
<lukego>
not an issue for proof-of-concept but if you wanted to rebuild historical quicklisp releases too you would need to match up the right version of the projects repo, and deal somehow with repos that have moved/disappeared in the interim. but good to always have tarballs to fall back on from quicklisp
<LISPer>
Performance is critical..
<p_l>
though I haven't recently checked if it still compiles under MSVC++ or needs alternative compilers
<Nilby>
Xach: basiclly just mapping "git clone" through quicklisp-projects/projects/*
<LISPer>
I really like ACL for it's performance
<p_l>
LISPer: then go with SBCL 64bit
<phoe>
LISPer: go for SBCL then, it has an aggressive compiler.
<bitmapper>
not really common lisp, but i've been working on the Thomas implementation of prefix Dylan
<bitmapper>
Thomas 1.2
<bitmapper>
Exit by typing "thomas:done"
<bitmapper>
? (define-class <pepsi> (<object>))
<bitmapper>
Result: <PEPSI>
<bitmapper>
?
<p_l>
was that the Digital one?
<bitmapper>
yes
<bitmapper>
i've gotten it working on chez scheme
<bitmapper>
and on scheme2c again
frgo_ has joined #lisp
jonatack has joined #lisp
<theseb>
Please allow me to confirm this again..still confused....so can macros treat free variables just like regular functions do with lexical scoping?
<theseb>
There is no inherent reason macros must "ignore the environment" ?
<theseb>
yes?
frgo has quit [Ping timeout: 240 seconds]
theBlackDragon has quit [Ping timeout: 258 seconds]
EvW1 has joined #lisp
<bitmapper>
theseb: depends
<theseb>
bitmapper: what do you mean? on what?
<bitmapper>
if you are quasiquoting or not
<phoe>
theseb: macros, or macro expansions?
<bitmapper>
actually, just quoting
<phoe>
in the former case, just replace DEFMACRO with DEFUN and the function will work the same
<phoe>
in the latter case, depends on the context in which the macro is expanded
<theseb>
phoe: macro expansions
<phoe>
theseb: I don't understand the question then
<theseb>
phoe: give a minute to try to make a better phrasing
<phoe>
the macroexpansion is just a Lisp form; whatever symbols are inside it are then attempted to be parsed as if the macro wasn't even there in the first place
theBlackDragon has joined #lisp
Josh_2 has joined #lisp
<theseb>
phoe: so macro expansions you said depend on the context in which they are expanded
<phoe>
theseb: a macroexpander is just a function
<phoe>
it can close over stuff from its lexical environment
<theseb>
phoe: why not also the context in which the macro was *defined*?...Isn't that what lexical scoping means?
<phoe>
it can use globally defined stuff as well
<Bike>
i think you're over thinking this.
<phoe>
^
<Bike>
a macro function is just a function. it can be a closure like any function, though that's not common.
<Bike>
all the function does is take a form as input and output another form.
<Bike>
it doesn't know jack shit about that form's variables or functions or whatever.
<phoe>
(let ((x 42)) (defmacro foo () x)) ;; look ma, lexical closure in a macro!
<phoe>
as I said, if you have a macro problem, just replace DEFMACRO with a DEFUN and think again from this perspective
<theseb>
phoe: actually...great example....if your (let.....) ok? it isn't against the rules?
<theseb>
s/if/is/
<phoe>
theseb: which rules
<phoe>
the only thing that breaks is toplevelness
<phoe>
which effectively means that you cannot use the macro in the same file, only in files that you load lader
<phoe>
later*
<theseb>
phoe: why can't you use it in the same file?
<Bike>
theseb, what do you think is wrong with this let defmacro example.
<phoe>
^
<Bike>
what rule are you referring to.
<Bike>
i already tried to explain non top level macros to you like last week, and i thought you understood.
<theseb>
Bike: maybe rule wasn't the right word
grumble has quit [Quit: As we empty our lint traps, we're just slowly throwing our clothes in the garbage.]
<theseb>
Bike: i think i got it now when phoe said (let ((x 42)) (defmacro foo () x)) was valid
<theseb>
Bike: just wanted to confirm that
<phoe>
this is essentially (let ((x 42)) (setf (macro-function 'foo) ...))
<phoe>
where ... frobs the macro body a lil bit
<phoe>
inside ..., there is a (lambda () x) at some point
<phoe>
look, a perfectly normal lexical closure
efm has joined #lisp
keepzen has left #lisp [#lisp]
<theseb>
phoe: (let ((x 42)) (defmacro foo () x)) <--- and further down in the source it is ok to use (foo) ?
<theseb>
phoe: and it will return 42?
<phoe>
theseb: not in the same file
<phoe>
but in the next files, yes
<phoe>
(foo) will expand into the Lisp form 42 which will evaluate into 42
grumble has joined #lisp
<Bike>
because, as i tried to explain before, the compiler can't create the macro function at compile time without evaluating the entire (let ...) form.
<theseb>
Bike: is common lisp always compiled? what if it was interpreted (no compilation step)...then would it be ok to use in same file?
<Bike>
if you load the file that's okay, sure.
<Bike>
then it just evaluates each form one at a time.
<theseb>
oh good
<Bike>
but having a file that works when loaded but not when compiled is kind of confusing.
<phoe>
I need to write a full blogpost about it someday
_mixfix41_ has joined #lisp
KingRagworm has joined #lisp
<theseb>
Perhaps a lisp DSL would make a really complex machine learning problem doable....maybe i can make a macro heavy lisp program that does mind blowing machine learning
<theseb>
that may be a money maker
<phoe>
IMO Lisp won't blow anyone's mind, including yours
<phoe>
it's a very good and battle-tested programming language
<lukego>
So I have various grudges against Hetzner, EC2, and GCE. What options does that leave me for a convenient economical high-bandwidth env for playing with downloading lots of Quicklisp projects?
<theseb>
They said lisp had an "AI Winter".....imho...with the new AI renaissance (deep learning!!!!).....i don't see why lisp can't now have an "AI SPRING!"
<theseb>
phoe: i love this..."some prominent faces in the programming world in general, have been writing about Lisp as secret sauce, silver bullet, source of programming enlightenment, yadda yadda"
<phoe>
theseb: that, in turn, is my 2¢
Blukunfando has quit []
<theseb>
phoe: this is hilarious... other than causing some people to indeed try Lisp, have left a lot of people confused and amused by the wording - or just plain angry and disappointed at the false marketing that I consider the above hyperboles to be
<theseb>
phoe: yea ..it least it gets people in the door ;)
<theseb>
phoe: then they get pissed by the false marketing lol
<phoe>
theseb: also gets people outta the door.
<Odin->
Sometimes, people being interested for the wrong reasons is worse than not being interested.
<phoe>
but I found that people don't really talk about the latter.
KingRagworm has quit [Remote host closed the connection]
<phoe>
well, until it's too late, anyway
lavaflow has quit [Ping timeout: 260 seconds]
<theseb>
phoe: in all fairness to the "silver bullet meme"....every once in a while......I'll hear about some DARPA challenge or programming contest somewhere and some obscure submission will win ...then i find out it was done in lisp
<theseb>
phoe: that's my best anecdote i can think of for the "lisp has super powers!!!!"
<theseb>
but maybe they would have won with python just as well as you would say
<theseb>
perhaps
<phoe>
theseb: it doesn't. It's just a really good combination of well-thought-out mechanisms that make programming and debugging pleasing.
<theseb>
phoe: yes but that in itself may be a competitive advantage in using lisp.....perhaps not magical but significant
<phoe>
the "magic" is the fact that the whole world is going it the wrong way around, seriously; Lisp and Smallktalk and, surprisingly, HolyC from TempleOS all have these superpowers by being image-based interactive programming languages will full introspection and debugging.
<MichaelRaskin>
Also, Erlang?
<phoe>
HolyC "purposefully" doesn't have memory safety, but that's not relevant.
<phoe>
Erlang, too, sure thing
renzhi_ has joined #lisp
<theseb>
phoe: your point i think is that it isn't so much that lisp is magical as that other solutions are so bad
<theseb>
by comparison
<theseb>
makes sense
<phoe>
it's just "worse is better" in practice
<phoe>
nothing magical about it either
lavaflow has joined #lisp
liberliver has joined #lisp
<MichaelRaskin>
To be fair, Python used right can also be used for image-based-like development and it has a ton of introspection
<phoe>
I am curious to see anything like SLIME developed for it though
<phoe>
or does such a thing already exist?
ayuce has quit [Remote host closed the connection]
<MichaelRaskin>
SLIME is one possible way of doing editor integration
ayuce has joined #lisp
<MichaelRaskin>
There are definitely debuggers for Python allowing you to evaluate code in any of the stack frames
<Xach>
lukego: i use ovh
jruiz has quit [Ping timeout: 260 seconds]
EvW1 has quit [Ping timeout: 246 seconds]
toorevitimirp has quit [Remote host closed the connection]
oxum has quit [Remote host closed the connection]
madage has quit [Remote host closed the connection]
madage has joined #lisp
<theseb>
Odin-: you there?
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
<theseb>
phoe: whoa....HolyC / TempleOS interesting story
<phoe>
it's a single-ring OS, just like Mezzano
<phoe>
the whole programming language is image-based, not unlike Lisp or Smalltalk
Aurora_v_kosmose has quit [Quit: Пока, мир.]
Aurora_iz_kosmos has joined #lisp
Aurora_iz_kosmos is now known as Aurora_v_kosmose
ralt has joined #lisp
<theseb>
phoe: afaict 'image based' means...'you can control and modify nearly everything'
sbodin has quit [Read error: Connection reset by peer]
<phoe>
>
<phoe>
> An image-based language is a language in which the primary means of development consists of programmers modifying an (usually in-memory) image of the runtime environment.
<lukego>
So! If you clone all of the quicklisp-projects with source 'git <url>' it's 2.0GB with full git history and 1.5GB with --depth=1.
<lukego>
So not really that big in the grand scheme of things although I dunno if Github is happy about pushing 2GB repos
<lukego>
have to incude more sources though
<lukego>
that's 1619 projects
<lukego>
So quicklisp2monorepo with full history (e..g git subtree/git subtrac) seems plausible for now
oxum has joined #lisp
<theseb>
phoe: ever heard of ESR? he's another writer that writes about the "lisp enlightenment"...then he goes and uses Python and Go
<lukego>
interesting if git-fu would allow you to construct a branch containing only the packages you actually want and not pull the rest. the git-subtrac docs seemed to hint in that direction but I didn't understand jack on the first reading
<phoe>
theseb: yes, I've heard about it, and I consider him a part of the issue.
<theseb>
phoe: i think we can possibly save the whole 'enlightenment' marketing campaign if we tone down what we mean by enlightenment.....It perhaps only means something as benign as "Wow I didn't know a language could be implement with so little primitives!"
<theseb>
phoe: it is half in jest and half for fun i guess
<theseb>
i mean half in jest and half being serious
<lukego>
github say the max repo size is 100GB, with a soft limit / warning at 75GB, so lotsa headroom there
kingcons has quit [Quit: ZNC 1.6.5+deb1+deb9u2 - http://znc.in]
TMA has joined #lisp
<lukego>
Have to think about how to make this play with Nix. Ideally wouldn't import a zillion copies of the monorepo into the Nix store. Maybe you'd separately checkout the monorepo and then have Nix cherry-pick packages from that. Maybe even still use ql2nix but sourcing the packages from the monorepo.
<lukego>
or if the monorepo were used as quicklisp/local-projects you could even have as many or as few packages in there as you wanted and let quicklisp source any that are missing. but have to think about whether I'm going in circles and ending up back at the submodules idea here more-or-less.
_mixfix41_ is now known as mixfix41_lied
<lukego>
and have to consider the use cases and whether this whole idea is more trouble than it's worth
Fare has quit [Ping timeout: 256 seconds]
fourier has joined #lisp
arpunk has joined #lisp
kpoeck has quit [Remote host closed the connection]
<Nilby>
perhaps one doesn't really need all of it, but of course some things are essential, clinch-20180228-git/examples/assets/img/comic-with-shark.jpg gendl-devo-a6b5a5f8-git/gwl/static/gwl/images/slack_out.gif
Nilby has quit [Read error: Connection reset by peer]
<gendl>
Not having time now to read this whole feed, but it looks like folks are expressing concern about quicklisp system sizes? I know we have a lot of bloat in the gendl ql system. A lot of that was coming from the PDF of our manual, which I thought I got rid of. Is that still there?
<gendl>
Well, i guess it's my responsibility to check that...
Posterdati has quit [Read error: Connection reset by peer]
<gendl>
... just checked. tutorial.pdf and associated images have been in .gitignore for some time
<gendl>
Nilby: a few years ago we were ready to get rid of that slack_out.gif but a Fortune 500 customer (at the time) requested that we keep it. It pops up under certain conditions in our browser-based inspection and debugging environment.
EvW has joined #lisp
<gendl>
Fortune [much smaller number than 500, actually]
ayuce has quit [Ping timeout: 240 seconds]
karswell has joined #lisp
sdumi has quit [Ping timeout: 260 seconds]
Posterdati has joined #lisp
ayuce has joined #lisp
sdumi has joined #lisp
Felix__ has joined #lisp
Felix__ has quit [Remote host closed the connection]
ayuce has left #lisp ["ERC (IRC client for Emacs 28.0.50)"]
KingRagworm has joined #lisp
<Josh_2>
in cfb8 mode
<gendl>
... yeah i think it's time to dump the animated "Bob" Dobbs... just noticed those images are just south of 10 MB. There may well be copyright issues with having them in our repo as well. Apologies for that!
<gendl>
(referring to the slack_out.gif mentioned above by Nilby).
gko has quit [Ping timeout: 256 seconds]
Felix__ has joined #lisp
Felix__ has quit [Remote host closed the connection]
kingragworm_ has joined #lisp
kingragworm_ has quit [Quit: kingragworm_]
kingragworm_ has joined #lisp
kingragworm_ has quit [Client Quit]
kingragworm_ has joined #lisp
kingragworm_ has quit [Remote host closed the connection]
kingragworm_ has joined #lisp
theseb has quit [Quit: Leaving]
kingragworm_ has quit [Remote host closed the connection]
LisperWannabe has joined #lisp
<LisperWannabe>
Hello!
ayuce has joined #lisp
<phoe>
heyyy
<phoe>
what's up
cmatei has quit [Remote host closed the connection]
cmatei has joined #lisp
<LisperWannabe>
i need help with something
<phoe>
sure, what is it
<LisperWannabe>
have you ever used lispcord?
<phoe>
not personally; I think that some people on the Lisp Discord server have, given the nature of Discord
<Shinmera>
If you need help for that the github repo is your best bet.
<phoe>
but you might stay a while and listen or contact the gith--
<phoe>
yes
<LisperWannabe>
its giving me errors when i try to connect it, somethign to deal with ssl
brutalist has joined #lisp
<phoe>
LisperWannabe: oh! what sorta errors?
<phoe>
please use a pastebin
<LisperWannabe>
ok
<phoe>
maybe it's related to openssl missing from your machine
<phoe>
oh, OpenSSL is unable to verify the certificate issuer
<phoe>
I actually don't know how to fix that one; I'm not good at SSL stuff
<LisperWannabe>
oh ok, thanks for the help though
LisperWannabe has quit [Quit: WeeChat 2.7]
kpoeck has joined #lisp
<lukego>
I've pondered packaging for the better part of a dog-walk and I don't like the monorepo idea anymore. makes it too hard to try swapping in/out different versions e.g. hacks that other people have done. better to have an indirection that lets you pick an arbitrary version of a package. question is whether to use something built into quicklisp e.g. local-projects, or built into nix e.g. overrideDerivation, or built into git
dalz has joined #lisp
Guester8 has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
kpoeck has quit [Ping timeout: 245 seconds]
EvW has quit [Ping timeout: 260 seconds]
ljavorsk has quit [Ping timeout: 260 seconds]
kpoeck has joined #lisp
Oladon has joined #lisp
oxum has quit [Remote host closed the connection]
madage has quit [Ping timeout: 240 seconds]
<Guester8>
Hi, anybody used Parenscript? Would you recommend it over writing direct javascript?
<phoe>
announcement: Lisp Koans are now officially at version 2.0, my change was merged
jruiz has quit [Remote host closed the connection]
<bitmapper>
phoe: factor has images and a presentation based gui too!
<phoe>
bitmapper: TIL
madage has joined #lisp
<bitmapper>
it's actually really nice
nowhy has joined #lisp
Lycurgus has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]
akoana has joined #lisp
ljavorsk has joined #lisp
nowhy has quit [Ping timeout: 245 seconds]
Guester8 has quit [Ping timeout: 260 seconds]
ljavorsk has quit [Ping timeout: 264 seconds]
rumbler31 has quit [Remote host closed the connection]
ATuin has joined #lisp
dalz has quit [Remote host closed the connection]
ljavorsk has joined #lisp
<lukego>
I think I'll step back from the abyss for now actually. My little ql2nix setup works well for a medium number of stable dependencies and I should probably focus on using that to actually write some code of my own. CLIM and packaging-hacking are attractive yaks but probably a distraction atm.
<lukego>
I'm very curious to see how McCLIM looks these days though, maybe oughta YouTube some recent demos
SGASAU has quit [Remote host closed the connection]
<shka_>
i done some mcclim programming in past months
SGASAU has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<shka_>
in terms of ways of how interactions are managed clim is a work of genius
mikecheck has joined #lisp
Fare has joined #lisp
<shka_>
and honestly, i am under the impression that it is practical library for certain types of applications
<shka_>
if i would attempt to write a web framework, i would try to mimic mcclim architecture
<shka_>
so thumbs up
<lukego>
I need to spend some quality time with org-babel.
<lukego>
I have an equally torturous nix-based packaging of Emacs with various packages and settings that I need to amortize the setup cost of by actually using :)
<lukego>
albeit that's mostly just using upstream support
oxum has joined #lisp
<lukego>
I also have some exotic notions like generating Blender models and interacting with them there instead of creating realtime UIs. no idea if that's practical but should actually try it :)
<lukego>
thanks all for the Quicklisp tips today. will surely come back and shave this yak in the future :)
oxum has quit [Ping timeout: 260 seconds]
<jdz>
lukego: I think nobody has suggested creating your own Quicklisp dist. Not sure it would help, though.
<jdz>
I know there's ultralisp.
<lukego>
yeah that's the direction my thoughts were wandering
<jdz>
I was thinking something like vanilla Quicklisp dist with an overlay of your "patched" libraries.
lavaflow has quit [Ping timeout: 264 seconds]
azureBlob has joined #lisp
nullniverse has quit [Ping timeout: 244 seconds]
<lukego>
also when what I'm doing is speculative, like spending an hour or two playing with McCLIM, maybe just ditch my whole setup and e.g. try it in an Ubuntu VM to see if it makes sense to package up
<lukego>
but, I do lament a bit not having read/write copies of my dependencies, and so being unlikely to contribute anything useful upstream due to friction
EvW has joined #lisp
<gendl>
Nilby: Done. Purged.
KingRagworm has quit [Quit: kingragworm]
fourier has joined #lisp
<azureBlob>
Hello! I'm trying to learn lisp and I found a situation that looks like it would be a good place to make a macro, but I can't seem to get it right, I'm trying to make a macro that takes a number and a list of numbers and return values, that compares the given number with the list number and returns the smallest valid return value for that number, I think I need this to expand to a cond block, but idk how to turn the list of checks to
<bitmapper>
i know i'm doing something that shouldn't be done
<p_l>
bitmapper: is it any closer to working than it was over the last decade and a bit?
<bitmapper>
p_l: considering it runs!
<bitmapper>
gnu lightning 1.2 from git has 64bit support
<p_l>
that's a huge jump, indeed
<bitmapper>
it just crashes when compiling one of the files
<bitmapper>
due to a pointer issue, most likely
Jesin has quit [Quit: Leaving]
oxum has joined #lisp
karayan has joined #lisp
nika has quit []
Jesin has joined #lisp
gravicappa has quit [Ping timeout: 272 seconds]
Lord_of_Life_ has joined #lisp
oxum has quit [Ping timeout: 256 seconds]
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
ayuce has quit [Remote host closed the connection]
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
pve has quit [Quit: leaving]
kpoeck has quit [Remote host closed the connection]
ATuin has quit [Quit: WeeChat 2.8]
rumbler31 has joined #lisp
hsaziz has joined #lisp
terpri has quit [Remote host closed the connection]
EvW1 has quit [Ping timeout: 252 seconds]
hsaziz has quit [Client Quit]
z147 has joined #lisp
terpri has joined #lisp
sugarwren has quit [Quit: Leaving]
terpri has quit [Remote host closed the connection]
dalz has quit [Remote host closed the connection]
terpri has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
SGASAU has quit [Remote host closed the connection]
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
SGASAU has joined #lisp
frgo_ has quit [Remote host closed the connection]
theseb has joined #lisp
frgo has joined #lisp
EvW has joined #lisp
lavaflow has quit [Ping timeout: 256 seconds]
lavaflow has joined #lisp
<theseb>
Possible to implement progn in a CL subset if I don't have a lambda form or macro system that allows unlimited *parameters* ?
<theseb>
(My lambda allows unlimited bodies of code...just not unlimited input values)
<Bike>
you can do progn with function calls
<Bike>
(progn a b) = ((lambda (_) b) a), for example
<Bike>
kind of a stupid implementation, though
<theseb>
Bike: wait..it has to allow unlimited args...so what about (progn a b c d e f ...) ?
<theseb>
Bike: do you need n lambdas for n args?
<Bike>
(progn a b c) = ((lambda (_) ((lambda (_) c) b)) a)
madage has quit [Ping timeout: 240 seconds]
<theseb>
Bike: what i'd like to do is convert (progn a b c d ...) to ((lambda () a b c d ...)) but i can't see how to do that w/ my limitations
<Bike>
er, w hat.
<Bike>
if you can do (lambda () a b c d) i mean... that _is_ progn.
<theseb>
Bike: yes exactly...but i don't think i can write a macro to do that
<theseb>
Bike: because when you specify the macro called progn it cannot have unlimited args
madage has joined #lisp
<Bike>
....yeah it can?
<Bike>
(defmacro progn (&rest forms) ...)
<theseb>
Bike: well not with my CL subset and its constraints unless i'm mistaken
<Bike>
but if you support lambda bodies with multiple forms why even have progn as a macro? just... support progn directly
<Bike>
these constraints sound kind of absurd
<theseb>
Bike: i wanted to minimize the number of special forms!
<Bike>
that's not really an exercise with any point
<theseb>
Bike: i thought it would be elegant
<Bike>
also, that doesn't rule out having &rest lambda lists, does it?
z147 has quit [Quit: z147]
<Bike>
meaningless
<theseb>
Bike: i guess i have to add &rest
<theseb>
that would do it
<Bike>
if you want to worry about "minimalism" just use lambda calculus or some other formalism
<Bike>
if you have "CL but less" you have something with too much to be useful mathematically but too little to be useful for programming
<theseb>
Bike: if i had to scrape the bottom of the barrel i think i could cook up one reason to be so anal about minimalism...watch this....
<theseb>
Bike: imagine a future world where computer security is a vital concern....people want to formally mathematically verify their code....they will be screaming for minimal OSes and languages
<theseb>
Bike: how about that? does that work for you?
<Bike>
you think security will be enhanced by admitting progn?
<Bike>
do you actually know anything about program verification?
<Bike>
omitting, not admitting
<Bike>
talking is hard
<theseb>
Bike: no i don't know anything about verification....but just like microkernels...i think the philosophy is to have the smallest verifiable kernel