<whartung>
I recall, long ago, with Franz lisp, running multi-threaded, having a routine that was just running (x) in a loop, and seeing it go from “hello” to “goodbye” when I re-defun’d x. “Hazah!”
<whartung>
(And here we splash in more disclaimers abou thte global environment and threading and yada yada)
<whartung>
But we also know, that this is more of the first class concept in the system and the language. It’s “supposed” to do this. Even to the point the CLOS has a protocol for changing class instances in flight.
<whartung>
when you add slot new-slot to an CLOS class, you can write code to properly update that for existing instances of that class. Pretty snazzy.
<whartung>
Now, Java.
<whartung>
Java is a different beast.
<whartung>
You first have to appreciate that with Java, we like to think all about classes, and think clases are king and such.
<whartung>
And, we would be wrong.
<whartung>
Classes are not king.
<whartung>
ClassLoaders are king.
<whartung>
By definition, a class is a combniation of the class and the classloader.
<whartung>
When you reload in an IDE, it tries to go and do surgery on the heap.
<whartung>
If you try to, say, reload a JSP in a web container, that’s a diffrent problem. That creates a new class from the JSP, and swaps out the old one that’s mapped by the URL of the JSP. So, when you hit test.jsp, it just loads the new class, not the old one.
<whartung>
Dynamically loading classes in java is EZ.
<whartung>
Dynamically changing classes, not so much.
<whartung>
That’s much more of a hack. It why the reloads aren’t always successful. It’s one thing to reload the class of, say, a web controller. Something that has, you know, one instance. Big deal.
<whartung>
It’s another to reload the class of, say, a JPA Entity, like Employee, that you happen to have 10,000 instances cached.
m00natic has quit [Remote host closed the connection]
<drduck>
So full feature dynamic reloading in lisp is by design and it's a hack -- also sometimes only partially works -- in java?
<whartung>
Java can’t “update” instances. it can’t add slots to old classes. And, depending on how the class was redefined, your cached objects may well no longer be of the “same class”. If the new class has a different class loader, then when “new code” tries to cast “new Employee” from a instance of “old employee” that’s in the cache (and Java ALWAYS casts under the hood), it’ll fail. “CLass Cast Exception”, because Employee is no lon
<whartung>
Employee any more. IT’s ClassLoader2.Employee != ClassLoader1.Employee.
<whartung>
yes.
<whartung>
It’s much more of a first class concept (with all the warts and caveats) in Lisp than it is in Java.
<drduck>
I wish I could comprehend a little better what that actually means in a freshman-esque case study.
<drduck>
Probably one of those things I'll just have to experience, eh?
<whartung>
It means that redefining dynamic elements in a runtime system is not always simple.
<whartung>
Lisp, out of the box, is dynamic at the price of performance. Lisp can be made “faster” through declarations that limit the flexibily.
<whartung>
For example, the CL package is specifically defined by the standard to really not have the dynamicity of other Lisp code.
<whartung>
Consider the “+” function, nobody on the planet wants to invoke a function call for +. It’s just crazy.
<whartung>
so, (+ 1 1) isn’t really a function call when it’s been compiled. Redefining “+” isn’t going to work like redefining X would, right?
<whartung>
but that’s why the CL package is specifically exempted, so the compiler can do reasonable stuff.
<whartung>
out of the box
<whartung>
Runtime systems make a lot of assumptions, Java assumes that’s its really in a pretty static environment. The CLassLoader is the barrier that helps boundary the dynamic behavior.
<whartung>
Consider loading a webapp in Tomcat
arduo has quit [Ping timeout: 240 seconds]
<whartung>
when you load a web app, Tomcat will create a new ClassLoader, and THAT loads in your web app and it’s classes and stuff.
<drduck>
yes
moei has quit [Quit: Leaving...]
<whartung>
When you undeploy the webapp, the classloader gets destroyed, and that’s the link in the chain that keeps your app in memory. With that gone, the GC marches through and kills everything
<whartung>
but out of the box, Java doesn’t really like the underlying structure of its classes to change. The ClassLoader give Java a lot of dynamic behavior.
<whartung>
But changing class structure in flight is not one of them. Rather, they want you to toss away the old, and brin gin the new
<whartung>
but there goes not just your class, but the 10,000 cached Employee instances as well.
<whartung>
So, the relaoding capablity of the IDEs is a magic trick, It mostly sorta works.
<drduck>
what happenes to the 10,000 cached Employee instances in common lisp in this scenario?
<whartung>
but that’s also because most of the use cases are folks updating application logic, changing a web controller, or some other “mostly” stateless bit of code.
<whartung>
Well, in CLOS, there structure will change. You can try it and see.
caltelt has joined #lisp
<whartung>
hang on
<whartung>
so, see, this is a struct in lisp — and structs are “hard” strcutures, like in C
<whartung>
but notice the different message when we try to access ‘d between when we redefined the classes
<whartung>
I’d have to dig a bit to find an example that uses the clos redefinition protocol — see if that works
pioneer42 has joined #lisp
<drduck>
oh nice
patlv has quit [Ping timeout: 264 seconds]
<drduck>
so the qq modified its instance of c to match the newly defined structure
parjanya has quit [Read error: Connection reset by peer]
<drduck>
i should start up the java10 interpreter and see what happens in a case like this
sjl has joined #lisp
<whartung>
now, for the CLOS implementaion in CLISP, in theory the structure is supposed to updated when the class is redefined, apparently by default CLISP doesn’t support that.
<whartung>
but the fundamental point is that the two environments live with two different base assumptions.
<whartung>
Java is a static world, and while it can easily handle loading new classes, it’s not really set up to allow them to change, especially structurally.
<whartung>
Lisp is a much more dynamic world.
<whartung>
when an IDE reloads classes, it’s doing a magic trick that may well not always work. It sometimes works.
<Bike>
the semantics are that when you redefine a class, instances of that class are updated (i.e. turned into instances of the new class) some point prior to you accessing one of their slots. and the update process is a generic function you can customize.
<whartung>
Personally, I don’t use it in Java. I don’t trust it, and I’d rather have things take longer, and work consistently, than things be faster and be inconsistent. I hate going after some strange bug that “goes away” when the image is restarted.
<drduck>
I guess same behavior when it is compiled as well?
<whartung>
that’s the behavir specific to the shell
nowhere_man has quit [Ping timeout: 256 seconds]
<whartung>
you have a binding of Foo that the shell realaized
<whartung>
so that’s why it “knew” to reset ‘f’ to null
<whartung>
(I’ve never used the jshell)
<drduck>
oh o.o
<whartung>
but that’s why is zapped it
<drduck>
Similar happens in hot reload for Java with class structure change?
<drduck>
The objects just get zapped?
<drduck>
instances*
<whartung>
no, it doesn’t that’s the point. If you have some Singleton out there reference a class that’s reloaded…who knows what happens.
<drduck>
:o
<whartung>
Like I said, it’s a magic trick.
<whartung>
“java doesn’t reload classes”
<whartung>
IDEs hack it and fiddle with it.
<whartung>
And, sorry, at this point I have to do my own magic trick and disappear. Hope this was helpful.
<whartung>
In summary, the reloading mostly works in Java, just don’t be surprised if it bites you at times.
<drduck>
Yes it was. Thank you!
krator44 has quit [Quit: --]
<whartung>
IN Lisp, it’s a more amenable to it, but that doesn’t make you “bite” proof.
<whartung>
if you’re chaning just logic, it’s much better than if you’re changing structure in java
<whartung>
ok, out the door….good luck! ask more questions….have fun.
<drduck>
:)
<drduck>
ok!
patlv has joined #lisp
markoong has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
_krator44 has joined #lisp
psqueak has quit [Quit: Page closed]
fikka has joined #lisp
_krator44 has quit [Changing host]
_krator44 has joined #lisp
_krator44 has joined #lisp
_krator44 is now known as krator44
bexx_ has quit [Quit: see you]
fikka has quit [Ping timeout: 260 seconds]
bitch has quit [Quit: The bitch has left the building.]
Lord_of_Life has quit [Quit: EliteBNC free bnc service - http://elitebnc.org - be a part of the Elite!]
patlv has quit [Ping timeout: 260 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Lord_of_Life has joined #lisp
drduck has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
bexx_ has joined #lisp
graphene has joined #lisp
karlosz has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
bitch has joined #lisp
karlosz has quit [Ping timeout: 240 seconds]
JuanDaugherty has quit [Quit: Exeunt]
patlv has joined #lisp
karlosz has joined #lisp
Jesin has joined #lisp
anewuser has joined #lisp
moei has joined #lisp
k4rtik has joined #lisp
kerrhau has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
Kundry_Wag has joined #lisp
reu has quit [Quit: こんなにも、世界はレプリスで満ちあふれていたのか？ もし、今自分の手を傷つけてみたら、同じように泡を立てて消えていくのか？]
ebrasca has joined #lisp
skidd0 has joined #lisp
<skidd0>
hello
<skidd0>
how do you (use-package) or its equiv to load a package (to-do) along with all sub-packages (to-do.lists)
fikka has joined #lisp
<Bike>
there's no such thing as "sub packages"
<skidd0>
okay so t0-do.lists is it's own package
<skidd0>
so i have an asdf .asd file
<skidd0>
and a package.lisp file
<skidd0>
using (asdf:make "to-do") compiles all the files
<skidd0>
into fasls
pierpal has joined #lisp
<skidd0>
is there a way to use something similare to load them into the active lisp?
<skidd0>
i mean, make the exported classes available to the REPL
<Bike>
packages and asdf systems are different things. kinda orthogonal.
<skidd0>
okay
<Bike>
and packages don't have dependencies or anything like asdf systems.
fikka has quit [Ping timeout: 240 seconds]
<skidd0>
so is there a way i can use a single (use-package) for all the many packages in my system?
<skidd0>
the packages i'm writing have some
<skidd0>
to-do.tasks needs to-do.lists
<Bike>
those are the system dependencies.
<skidd0>
right
<Bike>
the packages are different and do not have dependencies.
<Bike>
you can only use-package one package at a time
<skidd0>
okay
<Bike>
but, you could have one package that exports everything interesting from multiple packages.
<skidd0>
so there's no way around the tedium
<Bike>
and then use that one package.
Kundry_Wag has quit [Ping timeout: 240 seconds]
<skidd0>
oh
<skidd0>
like a to-do.full
<skidd0>
perhaps
<Bike>
something like that.
<skidd0>
that (:use)s all the other packages and exports the needed stuff..?
<Bike>
yeah.
<skidd0>
i guess it wouldn't need to export
<skidd0>
since by (:use)ing, it's grabbing the exports
Kundry_Wag has joined #lisp
reu has joined #lisp
pierpal has quit [Ping timeout: 260 seconds]
nicht has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
eli_oat has quit [Quit: eli_oat]
eli_oat has joined #lisp
<mfiano>
Is there any undefined behavior with regard to using WITH-SLOTS with a structure-object?
charh has quit [Quit: bye.]
skeuomorf has joined #lisp
skeuomorf has left #lisp [#lisp]
Kundry_Wag has joined #lisp
krrrcks has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
pierpal has joined #lisp
krrrcks has joined #lisp
drduck has joined #lisp
nicht has quit [Ping timeout: 248 seconds]
<drduck>
Does SLIME have support for debugging in reverse? Does lisp allow this in general?
<beach>
I know of no Common Lisp implementation that supports that. It would be fairly tricky, given the semantics of Common Lisp. I will be able to do some of that stuff with first-class global environments, but there are other things that are tricky, like modifying the readtable, etc.
<beach>
skidd0: Once a package is loaded, exported symbols are available. You just have to use an explicit package prefix. Lately, I have come to the conclusion that it's a bad idea to USE to many packages.
<beach>
Not only do you commit yourself to future modifications of those packages, but it also becomes harder to read the code, since you don't know from which package a symbol is used.
karlosz has quit [Quit: karlosz]
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
brettgilio has joined #lisp
karlosz has joined #lisp
nicht has joined #lisp
AetherWind has joined #lisp
<aeth>
Bike: In case you missed it, I did manage to get my metaclass to work. The method you said to redefine was too elaborate so I wrapped it with :around. The issue is that SBCL hardcoded the initargs for effective-slot-definition-class even though it doesn't for direct-slot-definition-class. So I have to make everything my direct-slot-with-checked-type and handle the case of a null checked-type.
<aeth>
It calls compute-effective-slot-definition-initargs which provides the initargs to effective-slot-definition-class. It uses the standard initargs.
<Bike>
oh. well that doesn't matter.
<aeth>
So checked-type was always nil when I was checking for it in effective-slot-definition-class
<Bike>
i mean you can like, override the method and stuff.
<aeth>
Override compute-effective-slot-definition-initargs? I could have.
<Bike>
but i've never bothered with an effective-slot-definition-class method that didn't just always return the same class, it's true
<aeth>
I have to assert the type check because check-type requires the type to be unquoted.
<beach>
mfiano: Yes, that's unspecified behavior.
<aeth>
Both assert or an evaled check-type give unhelpful messages. assert's a bit nicer.
<aeth>
On the other hand, since I have an assert there I could probably turn it into a general system, not just with guaranteed type checking. (It's a shame that :type isn't guarnateed to be checked)
<beach>
mfiano: WITH-SLOTS expands to SLOT-VALUE, and the page on SLOT-VALUE says: Note in particular that the behavior for conditions and structures is not specified.
drduck has quit [Remote host closed the connection]
<skidd0>
beach, thank you for your comment
<beach>
skidd0: Anytime.
<skidd0>
i suppose using prefixes isn't too bad
<skidd0>
just feels odd
<aeth>
mfiano: Afaik, with-accessors can be assumed to be safer and more efficient with CLOS objects, and it works on just about anything with the simple accessor form (not just CLOS objects and structs, even accessors like car and cdr).
<beach>
skidd0: I personally USE only the COMMON-LISP package nowadays.
<skidd0>
then how do you accesss the symbols in other packages
<beach>
package prefix
<beach>
(clim:draw-line* ...)
<skidd0>
so you don't need an export to use it?
<beach>
You still need to export the symbols to do that.
<skidd0>
or does your package still export them
<skidd0>
but you don't (:use) them
<beach>
Correct.
<beach>
skidd0: Exporting a symbol means that it is meant for client code to use.
<aeth>
Personally, I USE CL and my own packages, and try to USE nothing else with rare exceptions. I use import-from, but it's not perfect for some things. e.g. Apparently if you forget to import a class, it doesn't fail when you inherit from that non-existent class.
<skidd0>
so does USE_PACKAGE negate the need for prefixes?
<beach>
skidd0: Whereas USE only has to do with whether you need a package prefix or not.
<skidd0>
and doed USE do the same thing?
<skidd0>
oh
matzy_ has joined #lisp
<beach>
skidd0: But you will do yourself a favor if you use explicit package prefixes. When you come back to your code in the future, you will have forgotten from which package a symbol comes if you can't see the package prefix.
<skidd0>
okay that's a good point
fikka has joined #lisp
<beach>
skidd0: And even if you have exceptionally good memory, the people who want to use your code and maintain it will have no clue where those symbols come from.
<matzy_>
i have a noob-ish question. for cl-cffi-gtk (gtk bindings for cl) where do you put the folder that you can load it with the command (asdf:load-system :cl-cffi-gtk)?
<skidd0>
that's implying people want to use my code
<beach>
skidd0: That's pretty much the assumption here on freenode isn't it?
BitPuffin has quit [Remote host closed the connection]
<matzy_>
everyone says to use that command to instll it, but i dont see where you can even point it to the dir. should i put it in my quicklip folder? i thought that was bad for manually installed packages
<beach>
mfiano: And notice that there is no definition of "CLOS object" in the Common Lisp HyperSpec. The only reasonable interpretation of such a term would be "any Common Lisp object" (since every Common Lisp object is an instance of a class) which makes it meaningless.
<skidd0>
anddownload this doc
<skidd0>
ty
<aeth>
beach: What's an object defined by defclass called?
fikka has quit [Ping timeout: 240 seconds]
<beach>
skidd0: Nowadays when I look at some code that I wrote a few years back, I deeply regret having overused USE, because I have no clue where those symbols are coming from, so maintaining that code is a nightmare. I usually start such maintenance by removing the USEes and inserting package prefixes. But even that exercise is VERY DIFFICULT.
<skidd0>
sounds like technical debt
anewuser has quit [Quit: anewuser]
tripty has quit [Quit: Gone fishin' ...]
Kundry_W_ has joined #lisp
fikka has joined #lisp
shka1 has joined #lisp
wigust- has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
Kundry_W_ has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 260 seconds]
karlosz has quit [Client Quit]
wigust has quit [Ping timeout: 264 seconds]
nicht has quit [Ping timeout: 256 seconds]
<skidd0>
do i have to export a class accessor?
fikka has joined #lisp
<mfiano>
beach: thanks
<mfiano>
skidd0: only symbols can be exported
<beach>
mfiano: Anytime.
<beach>
skidd0: Any symbol that is intended to be used by client code should be exported.
<skidd0>
so an accessor isn't a symbol?
<beach>
skidd0: Symbols are NAMES.
<skidd0>
i thought exporting the class was enough
<mfiano>
common lisp has many namespaces. an acceaaor symbol may be a few other things too
<beach>
skidd0: You don't export classes or functions.
<mfiano>
accessor*
<beach>
skidd0: You export symbols.
<skidd0>
*i thought exporting the symbol for the class was enough
<skidd0>
to get the accessor
<beach>
skidd0: It will not export the name of the accessor.
<beach>
skidd0: Luckily!
<beach>
skidd0: because not all accessors are intended to be used by client code.
<skidd0>
so i have to do that manually, should i want another package to be able to use it
<mfiano>
Correct
<beach>
skidd0: You are using the wrong terminology.
<skidd0>
should i want anything external to the package to have access to the accessor
<beach>
skidd0: No you don't have to. Others can use the double package prefix. But exporting is a signal that it is meant for client code to use.
<skidd0>
but i thought doubles were no good
<skidd0>
bad code
<beach>
skidd0: That's correct.
<beach>
But you said "able to" and "have to".
fikka has quit [Ping timeout: 244 seconds]
<skidd0>
ah
<beach>
The correct terminology would be more like "ought to".
<skidd0>
i see
jibanes has quit [Ping timeout: 240 seconds]
<beach>
skidd0: When you design a module, you first decide on a "protocol".
rumbler31 has quit [Remote host closed the connection]
<skidd0>
so if i had a TASK-LIST with a TASKS slot (that had a :accessor tasks), i export :tasks?
<beach>
skidd0: A protocol is a collection of types (usually classes) and functions (usually generic functions) that is all the client code needs in order to use your module.
<skidd0>
or :task-list tasks?
<mfiano>
You may even have multiple accessors per slot, and only a selection of them exported for users.
<beach>
skidd0: Then you export the names of those things.
<skidd0>
beach: the protocol basically a collection of higher leverl interfaces to the lower level code
<beach>
skidd0: You have a lot to learn. It is hard to keep up with your questions.
<skidd0>
i'm sorry
<skidd0>
i'm trying to learn
jibanes has joined #lisp
brettgilio has quit [Remote host closed the connection]
<beach>
skidd0: Yes, a module (not a Common Lisp term) consists of a protocol (or interface) and its implementation.
<skidd0>
mfiano: why would i want multiple accessors?
<skidd0>
beach, okay. I think i'm on the same page there
<beach>
skidd0: Because you might want the client to be able to define an auxiliary method on one but not on the other.
<skidd0>
oh okay i see
<beach>
skidd0: The small part is the protocol and the big part is the implementation. So you don't want to reveal the implementation in your protocol.
<beach>
skidd0: In particular, slot names should be an implementation detail.
<mfiano>
What I typically do, is I define a reader which is exported, and an accessor symbol with a % prefix which is used internally. That way, users know the slot is read-only, and I can pre-populate it myself through the internal API
<beach>
So you don't export those. Only accessors, and only those accessors that make sense as independent functions, without any reference to slots.
graphene has quit [Read error: Connection reset by peer]
<skidd0>
i think instead i'll export a reader, like mfiano does, and create an accessor
red-dot has joined #lisp
tripty has joined #lisp
<skidd0>
well, keep the accessor
<mfiano>
Multiple accessors per slot starts to make sense when you think of the package system as a protocol for your users
<beach>
skidd0: Now for the technical details of :EXPORT in DEFPACKAGE. The :EXPORT and :SHADOW options of DEFCLASS take what is known as "string designators".
graphene has joined #lisp
<beach>
skidd0: A string designator can be a string, a character (denoting a singleton string) or A SYMBOL.
<mfiano>
Also note, that the HyperSpec defines "accessor" to be any of reader, writer, or accessor, which might make what I said a bit confusing otherwise
Kundry_Wag has quit [Remote host closed the connection]
<beach>
skidd0: The thing is that in Common Lisp, symbol names are usually typed in lower case and then turned into upper case by the reader.
<skidd0>
mfiano: so have you mostly beenusing "accessor" to mean the hyperspec def?
<beach>
skidd0: So it looks ugly to have to type :export "MY-ACCESSOR".
<skidd0>
or the specific type of accessor
<beach>
skidd0: Therefore, some people (like me) use symbols instead.
<beach>
skidd0: One possibility is to use symbols from the KEYWORD package, so like :export :my-accessor.
<skidd0>
ah so :my-accessor is a keyword?
<beach>
skidd0: I prefer using uninterned symbols like :export #:my-accessor.
brettgilio has joined #lisp
<beach>
skidd0: When the reader sees a : at the beginning of a token, it creates a symbol in the KEYWORD package, yes.
<skidd0>
gotcha
<skidd0>
so string designators might be: "EXAMPLE", "example", "a"
fikka has joined #lisp
<mfiano>
Those are all strings, which are also string designators
<beach>
or #\a, HELLO, :HELLO, #:HELLO
<skidd0>
so #\a is a single char
<beach>
Yes.
<skidd0>
HELLO is a symbol
<skidd0>
:HELLO is a KEYWORD symbol
<beach>
Yes, in the current package when it was read.
<beach>
Yes.
<skidd0>
#:HELLO is uninterned symbol
<beach>
Correct, you got it.
<skidd0>
uninterned meaning not.. "loaded?" into the current running lisp package
<skidd0>
or lisp .. memory?
<mfiano>
interned meaning it's not internal to the package.
<beach>
skidd0: You may want to look at 2.4.8.3 and 2.4.8.1 as well.
Pixel_Outlaw has quit [Remote host closed the connection]
<skidd0>
hmm
<matzy_>
is there a good guide on how to get a simple GUI app up and running using cl?
<matzy_>
preferably gtk at the lib
brettgilio has joined #lisp
fikka has joined #lisp
<mfiano>
matzy_: Probably not. GTK is a beast, and there isn't really anything "simple" about it, or really any GUI programming. Shinmera has created quite a few tools around Qt because of the fact, even though Qt's API is only slightly better.
<matzy_>
mfiano: so how would you build a native gui program with cl?
<matzy_>
or how do most people?
<mfiano>
i would use something more native to CL, like McCLIM. Or I would use something hosted, like SDL2 with OpenGL, or a web frontend if it fits the problem.
<matzy_>
Really I just want to make a gui app for my personal use. Ive been wanting to learn cl for a long time, and i finally have a worthwhile personal project to do with whatever language i want
fikka has quit [Ping timeout: 260 seconds]
<matzy_>
i use linux though, and havent had to bring in qt yet (run a tiling wm instead of DE)
dddddd has quit [Remote host closed the connection]
milanj__ has quit [Quit: This computer has gone to sleep]
<beach>
matzy_: I would personally avoid learning Common Lisp by writing a GUI application because GUI applications are hard.
Kundry_Wag has joined #lisp
<mfiano>
^
robotoad has joined #lisp
<beach>
matzy_: And you will have lots of problems if you start off by using FFI as well.
<beach>
matzy_: Debugging becomes a nightmare. You will have segmentation faults and other messy stuff that is typical in less safe languages.
<mfiano>
Start by learning Common Lisp. Not just using Common Lisp as a stepping stone to foreign libraries. You're bound to fall and get dirty
<beach>
matzy_: Plus, by mixing languages, you put yourself in a situation where you don't have any good debugging tools.
<beach>
matzy_: Now, McCLIM is a GUI toolkit that is (almost) entirely written in Common Lisp. But to use it, you need to know about generic functions and lots of other things that is not typical to learn in the beginning.
<matzy_>
it's pretty simple. I use arch + i3, so I just launch apps thrugh stuff like rofi. the problem comes when you cant remember an apps name (like, what was that pdf reader i instaled?). i wanted to build some GUI app organizer you could use to categorize and launch common gui apps. some small utility just for me
fikka has joined #lisp
<beach>
matzy_: McCLIM would be ideal for that.
<mfiano>
You'd be better off writing a rofi script for that using Common Lisp.
<beach>
matzy_: But it takes some investment to learn.
<matzy_>
all great points.....hmmm
<mfiano>
rofi can do more than just act as a dmenu replacement. It is scriptable, calling out to any binary to do the heavy lifting
<matzy_>
ive just been looking for something to do in cl for awhile, because im not one to sit through endless tutorials. i like learning by building something
<mfiano>
So use Common Lisp to do the backend work. then you aren't writing a GUI...you are leveraging what you already use
<matzy_>
mfiano: that's such a great idea
<matzy_>
how do i get cl to talk to rofi though? some c api?
<mfiano>
You can use uiop:run-program, etc, to call out to rofi within Common Lisp.
sauvin has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<matzy_>
wow...so i could take a list of all sysem apps in cl, filter to get how i want, and then present in a cutom rofi window?
Kundry_Wag has quit [Ping timeout: 240 seconds]
<mfiano>
Why not?
<matzy_>
this is an awesome idea. and really useful too, a perfec project to learn on. thanks a million for the idea man!
<mfiano>
Sure. Good luck.
patlv has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
sauvin has quit [Max SendQ exceeded]
JuanDaugherty has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
sauvin has joined #lisp
matzy_ has quit [Quit: Page closed]
rumbler31 has joined #lisp
fikka has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 244 seconds]
asarch has quit [Quit: Leaving]
Bike has quit [Quit: Lost terminal]
robotoad has quit [Read error: Connection reset by peer]
brendyn has quit [Ping timeout: 256 seconds]
robotoad has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
mooshmoosh has quit [Remote host closed the connection]
mflem has quit [Read error: Connection reset by peer]
red-dot has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
sknx has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 248 seconds]
Kundry_Wag has joined #lisp
igemnace has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<skidd0>
kj/quit
skidd0 has quit [Quit: WeeChat 2.1]
Inline has quit [Remote host closed the connection]
mathrick has quit [Ping timeout: 265 seconds]
vlatkoB has joined #lisp
pierpal has quit [Quit: Poof]
saki has quit [Quit: saki]
pierpal has joined #lisp
abeaumont has quit [Ping timeout: 276 seconds]
sveit has quit [Ping timeout: 276 seconds]
lin_ has quit [Ping timeout: 276 seconds]
ccl-logbot has quit [Ping timeout: 276 seconds]
snits has quit [Ping timeout: 276 seconds]
shachaf has quit [Ping timeout: 276 seconds]
cibs has quit [Ping timeout: 276 seconds]
jgkamat has quit [Ping timeout: 276 seconds]
schjetne has quit [Ping timeout: 276 seconds]
mm__redacted has quit [Ping timeout: 276 seconds]
Kaisyu7 has quit [Ping timeout: 276 seconds]
bend3r has quit [Ping timeout: 276 seconds]
mrSpec has quit [Ping timeout: 276 seconds]
drduck` has quit [Remote host closed the connection]
robotoad has quit [*.net *.split]
AetherWind has quit [*.net *.split]
orivej has quit [*.net *.split]
_whitelogger has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
robotoad has quit [Quit: robotoad]
iqubic` has joined #lisp
terpri has quit [Ping timeout: 240 seconds]
<iqubic`>
How are you guys doing right now?
ofi has joined #lisp
robotoad has joined #lisp
Arcaelyx has joined #lisp
itruslove has joined #lisp
dkrm has joined #lisp
kajo has joined #lisp
jasmith has joined #lisp
thekolb has joined #lisp
mjl has joined #lisp
devlaf has joined #lisp
jerme__ has joined #lisp
billstclair has joined #lisp
jasom has joined #lisp
alms_clozure has joined #lisp
voidlily has joined #lisp
rvirding has joined #lisp
adulteratedjedi has joined #lisp
banjiewen has joined #lisp
PyroLagus has joined #lisp
d4gg4d_ has joined #lisp
Kevslinger has joined #lisp
lieven has joined #lisp
esthlos has joined #lisp
iqubic` has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
flamebeard has joined #lisp
iqubic has joined #lisp
iqubic has left #lisp [#lisp]
bitch has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
parjanya has joined #lisp
bitch has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
krwq has quit [Remote host closed the connection]
thinkpad has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 240 seconds]
thinkpad has joined #lisp
nickenchuggets has quit [Quit: Leaving]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
scymtym has quit [Remote host closed the connection]
fikka has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 276 seconds]
rumbler31 has joined #lisp
gigetoo has quit [Read error: Connection reset by peer]
gigetoo has joined #lisp
fikka has joined #lisp
rumbler31 has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 240 seconds]
parjanya has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
parjanya has joined #lisp
graphene has joined #lisp
light2yellow has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
schjetne has joined #lisp
alter-schjetne has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
terpri has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
Smokitch has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
chiyosaki has joined #lisp
xificurC has joined #lisp
saki has quit [Ping timeout: 264 seconds]
igemnace has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
igemnace has joined #lisp
fikka has joined #lisp
hajovonta has joined #lisp
shka1 has quit [Ping timeout: 260 seconds]
nostoi has joined #lisp
<hajovonta>
hi
heisig has joined #lisp
saki has joined #lisp
mgsk has joined #lisp
chiyosaki has quit [Ping timeout: 260 seconds]
<beach>
Hello hajovonta.
<hajovonta>
hi beach
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
igemnace has quit [Quit: WeeChat 2.2]
mrSpec` has quit [Changing host]
mrSpec` has joined #lisp
mrSpec` is now known as mrSpec
nostoi has quit [Quit: Verlassend]
jfb4 has quit [Ping timeout: 240 seconds]
scymtym has joined #lisp
svillemot has quit [Quit: reboot]
svillemot has joined #lisp
iskander has quit [Ping timeout: 256 seconds]
iskander has joined #lisp
chiyosaki has joined #lisp
saki has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
saki has joined #lisp
igemnace has joined #lisp
MinnowTaur has quit [Remote host closed the connection]
chiyosaki has quit [Ping timeout: 276 seconds]
Folkol_ has joined #lisp
hhdave has joined #lisp
makomo has quit [Ping timeout: 276 seconds]
MinnowTaur has joined #lisp
saki has quit [Quit: saki]
vertigo has quit [Ping timeout: 240 seconds]
vertigo has joined #lisp
rumbler31 has joined #lisp
saki has joined #lisp
kerrhau has quit [Ping timeout: 265 seconds]
milanj__ has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
Kundry_Wag has joined #lisp
MinnowTaur has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 260 seconds]
yaewa has joined #lisp
hajovonta has quit [Quit: hajovonta]
moei has quit [Ping timeout: 256 seconds]
parjanya has quit [Remote host closed the connection]
ofi has quit [Remote host closed the connection]
schweers has joined #lisp
_cosmonaut_ has joined #lisp
angavrilov has joined #lisp
graphene has quit [Remote host closed the connection]
graphene1 has joined #lisp
graphene1 has quit [Remote host closed the connection]
ofi has joined #lisp
graphene has joined #lisp
m00natic has joined #lisp
zmt01 has quit [Read error: Connection reset by peer]
zmt01 has joined #lisp
m00natic has quit [Ping timeout: 276 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
random-nick has joined #lisp
m00natic has joined #lisp
Kundry_Wag has joined #lisp
cibs_ is now known as cibs
Kundry_Wag has quit [Ping timeout: 248 seconds]
dddddd has joined #lisp
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Folkol_ has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
aindilis has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
froggey has quit [Ping timeout: 240 seconds]
froggey has joined #lisp
terpri has quit [Ping timeout: 240 seconds]
dmiles has quit [Ping timeout: 240 seconds]
beaumonta is now known as abeaumont
logicmoo has joined #lisp
AetherWind has quit [Quit: Leaving]
Kaisyu has quit [Quit: Connection closed for inactivity]
lumm has joined #lisp
flamebeard has quit [Ping timeout: 256 seconds]
markoong has joined #lisp
milanj__ has quit [Quit: This computer has gone to sleep]
kajo has joined #lisp
brendyn has joined #lisp
cpape` has joined #lisp
cpape has quit [Ping timeout: 256 seconds]
cpape` has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
ykm has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
ykm has joined #lisp
chiyosaki has joined #lisp
saki has quit [Ping timeout: 268 seconds]
light2yellow has quit [Quit: light2yellow]
terpri has quit [Remote host closed the connection]
saki has joined #lisp
chiyosaki has quit [Ping timeout: 276 seconds]
FreeBirdLjj has joined #lisp
JuanDaugherty has joined #lisp
saki has quit [Ping timeout: 245 seconds]
FreeBirdLjj has quit [Ping timeout: 256 seconds]
saki has joined #lisp
LiamH has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
Arcaelyx_ has joined #lisp
patlv has joined #lisp
Kundry_Wag has joined #lisp
chiyosaki has joined #lisp
saki has quit [Ping timeout: 256 seconds]
xificurC has joined #lisp
Kundry_Wag has quit [Ping timeout: 276 seconds]
chiyosaki has quit [Ping timeout: 245 seconds]
Bike has joined #lisp
caltelt has quit [Ping timeout: 248 seconds]
azrazalea has quit [Quit: ZNC 1.6.2+deb2~bpo8+1 - http://znc.in]
caltelt has joined #lisp
azrazalea has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
ikki has joined #lisp
<xificurC>
(read (process-output (sb-ext:run-program "/bin/sh" '("-c" "export-lisp") :output :stream))) is there something inherently wrong with such code? It keeps hanging in some cases even though the internal program always finishes when running from the shell directly
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
aindilis has joined #lisp
<flip214>
xificurC: run-program waits for the process to close.
<flip214>
but the process will block if the pipe is too small to hold all the output at once.
<flip214>
=> deadlock.
<flip214>
use UIOP:launch-program (or use :wait nil), read the stream, and then explicitly let it stop (== read the return code)
<flip214>
xificurC: and/or use "strace" to find out what happens exactly
mindCrime has joined #lisp
<xificurC>
flip214: ah, I tried :wait nil and then (read (process-output process)) (process-close process) but forgot to return the read value... That works. uiop:run-program worked too so I knew it must be something me doing wrong
<xificurC>
flip214: I tried running strace and could only see write is waiting
<xificurC>
didn't realize that means the pipe is full
milanj__ has quit [Quit: This computer has gone to sleep]
<xificurC>
flip214: thank you
nowhere_man has quit [Ping timeout: 260 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Inline has joined #lisp
ykm has quit [Remote host closed the connection]
sendai_ has quit [Ping timeout: 240 seconds]
eagleflo_ is now known as eagleflo
brettgilio has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
subroot has joined #lisp
graphene has quit [Remote host closed the connection]
flamebeard has quit []
fikka has quit [Ping timeout: 240 seconds]
graphene has joined #lisp
patlv has quit [Ping timeout: 268 seconds]
heisig has quit [Quit: Leaving]
milanj__ has joined #lisp
nowhere_man has joined #lisp
mindCrime has quit [Ping timeout: 244 seconds]
JuanDaugherty has quit [Quit: Exeunt]
sjl_ has joined #lisp
vlad_ has joined #lisp
warweasle has joined #lisp
vlad_ is now known as DonVlad
wildbartty has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
nowhere_man has quit [Ping timeout: 264 seconds]
lin__ has left #lisp [#lisp]
HighMemoryDaemon has joined #lisp
<HighMemoryDaemon>
Caveman uses a syntax feature of Lisp I have not seen before. Ex. '@route GET "/"' - What is this syntax feature called?
<HighMemoryDaemon>
Reminds me of Python decorators.
<dlowe>
HighMemoryDaemon: you can define new syntax in common lisp
<_death>
reader macro
<random-nick>
HighMemoryDaemon: it's a reader macro defined by caveman
<HighMemoryDaemon>
Whoa..
<HighMemoryDaemon>
That is really cool.
<random-nick>
HighMemoryDaemon: reader macros work by telling the reader to call a function when encountering a certain character on the beginning of an expression
<random-nick>
the function gets the input stream and it returns the read expression
<random-nick>
the simplest reader macro is probably quote ('), which reads the following expression and returns it wrapped in a (quote ...) form
cpc26 has joined #lisp
charh has joined #lisp
<antoszka>
You can use reader macros to quite trivially create, say, a literal syntax for hashes.
<HighMemoryDaemon>
That is very cool. Not saying that it is worth doing at all, but using these macros, couldn't you do something like re-make the entire Python or Ruby programming languages..within Lisp?
<antoszka>
HighMemoryDaemon: To some extent, yes, but why would you? :)
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
fikka has joined #lisp
cage_ has joined #lisp
carmack has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
elfmacs has joined #lisp
fikka has joined #lisp
zaquest has quit [Quit: Leaving]
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
red-dot has joined #lisp
beach has quit [Ping timeout: 256 seconds]
beach has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
schweers has quit [Ping timeout: 240 seconds]
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
housel has quit [Read error: Connection reset by peer]
vhost- has joined #lisp
vhost- has joined #lisp
vhost- has quit [Changing host]
FreeBirdLjj has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
housel has joined #lisp
milanj_ has joined #lisp
milanj__ has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
fikka has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
shah^ has joined #lisp
rumbler31 has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
brendyn has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
jasmith has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 255 seconds]
al-damiri has joined #lisp
fikka has joined #lisp
MinnowTaur has joined #lisp
jasmith has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
fikka has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<beach>
What is a good way for a Common Lisp implementation to distinguish between a source file and a FASL file when loading?
fikka has quit [Ping timeout: 260 seconds]
<jasom>
beach: what do you mean? Like having a magic number at the beginning of all FASL files?
<beach>
Yes, stuff like that.
<beach>
But a magic number could be a lisp datum I guess. Hence my question.
hhdave has quit [Ping timeout: 256 seconds]
<jasom>
Start with two dots?
<beach>
Yeah, I considered that. Thanks.
<beach>
Uh oh. Dinner says my (admittedly small) family. I'll be back later.
<jasom>
I mean if someone starts their source file like ".. I AM A FASL AND I'M NOT LYING" then they deserve what they get :P
fikka has joined #lisp
lumm has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 255 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
fikka has joined #lisp
red-dot has joined #lisp
pjb has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
shka1 has joined #lisp
shah^ has quit []
rumbler31 has joined #lisp
elfmacs has quit [Ping timeout: 244 seconds]
sauvin has quit [Read error: Connection reset by peer]
rumbler31 has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
pierpal has quit [Quit: Poof]
Lauven has joined #lisp
pierpal has joined #lisp
housel has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 264 seconds]
housel has joined #lisp
azimut has joined #lisp
fikka has joined #lisp
lumm has joined #lisp
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
lumm has quit [Remote host closed the connection]
Folkol_ has joined #lisp
<beach>
jasom: I totally agree.
<jasom>
beach: I assume you saw https://blog.golang.org/ismmkeynote ? Of note is that they found the write-barriers to hurt throughput more than generational collection helped on programs with small heaps. They attribute some of this to good escape analysis in the compiler. They show typical pauses of 500us on an 18GB heap which is pretty good, though it sounds like heavy allocators can get starved for longer.
<jasom>
s/heavy allocators/non-steady-state heavy allocators
rippa has joined #lisp
<beach>
I had not seen that before. Thanks.
<beach>
I can't read it today because I am off to spend time with my (admittedly small) family, but I'll look at it tomorrow.
MinnowTaur has quit [Remote host closed the connection]
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
kuwze has quit [Ping timeout: 252 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
lumm has joined #lisp
seven-eleven has joined #lisp
eli_oat1 has joined #lisp
seven-eleven has left #lisp ["Leaving"]
fikka has quit [Ping timeout: 244 seconds]
Folkol has quit [Ping timeout: 256 seconds]
Folkol_ has joined #lisp
red-dot has joined #lisp
kaun has joined #lisp
random-nick has quit [Ping timeout: 276 seconds]
kaun has quit [Client Quit]
MinnowTaur has joined #lisp
fikka has joined #lisp
brettgilio has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
igemnace has quit [Ping timeout: 276 seconds]
lumm_ has joined #lisp
lumm has quit [Ping timeout: 245 seconds]
lumm_ is now known as lumm
fikka has joined #lisp
cage_ has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
igemnace has joined #lisp
potatonomicon has joined #lisp
fikka has joined #lisp
Lauven has quit [Quit: leaving]
k-hos has quit [Ping timeout: 268 seconds]
ikki has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 276 seconds]
Folkol has joined #lisp
lumm has quit [Read error: Connection reset by peer]
k4rtik has joined #lisp
k4rtik has joined #lisp
k4rtik has quit [Changing host]
lumm has joined #lisp
eli_oat1 has quit [Quit: Leaving.]
gravicappa has quit [Ping timeout: 276 seconds]
eli_oat1 has joined #lisp
fikka has joined #lisp
ikki has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
skidd0 has joined #lisp
igemnace has quit [Quit: WeeChat 2.2]
igemnace has joined #lisp
milanj_ has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
fikka has quit [Read error: Connection reset by peer]
m00natic has quit [Ping timeout: 276 seconds]
sknx has joined #lisp
k4rtik has quit [Ping timeout: 240 seconds]
makomo_ has quit [Quit: WeeChat 2.0.1]
random-nick has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
fikka has joined #lisp
DonVlad has quit [Quit: Time for me to go.]
rpg has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<skidd0>
so say i have a lisp package that does some cool thing. on SBCL i can (sb-ext:save0lisp-and-die ..) to create a binary and handle command line args [with unix-opts]. If I want to share that program, will each user need to install sbcl and then run the save-lisp-and-die stuff? Is there an easier way to share the binary?
<skidd0>
is this a question for cl-noobs?
fikka has joined #lisp
milanj_ has joined #lisp
<skidd0>
I haven't ever made a program to be distributed before, so please be understanding of any ignorance
<Bike>
save-lisp-and-die with ":executable t" embeds everything you need, i think.
igemnace has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 245 seconds]
DonVlad has joined #lisp
<skidd0>
yeah that's what i have
<skidd0>
but (again, i'm ignorant and ill-informed here), that binary is only good for other 64bit Arch distros?
<skidd0>
so i'd have probably want to save-lisp-and-die on a Windows and a Mac, and provide build instructions for linux?
eli_oat1 has quit [Quit: Leaving.]
<dim>
the binary depends on the platform, much like a binary compiled with a C compiler does, you can build a binary per platform (architecture) and have users download it, and save-lisp-and-die is a good way to do that
fikka has joined #lisp
<dim>
for instance I use that in the pgloader build system and we package the resulting binary for debian, debian users then apt-get install pgloader and it works for them, they don't even have to know the software is written in CL
<dim>
there's also a wrapper in uiop (that comes with asdf) that provides a portable facility around save-lisp-and-die
<dim>
I use that in a build.lisp file for one of my projects
<dlowe>
cool, I didn't know pgloader was in debian
<skidd0>
i thought architecture was more hardware specific, not OS
<dlowe>
it's both
<skidd0>
thanks dim
<skidd0>
oh okay
<dim>
it might be that the binary that debian hosts would work on CentOS, but I don't know about that, really
<dim>
never tried ;-)
<skidd0>
see, you think this is what they'd teach you in a Computer Science program
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 260 seconds]
<dim>
education is more about culture than practical craftmanship, in my opinion... see, you knew how to ask the right questions
<dlowe>
architecture covers "can this my code execute?" (i.e. CPU) and "does this use the same hardware access protocol that my code expects" (i.e. OS)
<dlowe>
there's ways to trick your program into running on both counts
<shka1>
good evening
<shka1>
any idea when common qt will support qt5?
<skidd0>
dim i knew to ask the right questions because i've been self teaching a lot
<skidd0>
dlowe: i see
<skidd0>
dim: but i see how education is more cultural
<skidd0>
i wish we had a culture of learning
<skidd0>
not education
<skidd0>
edu-dictation
<shka1>
wishes can only get you so far :-)
<skidd0>
that's why i have legs and the mind to use em
Josh_2 has joined #lisp
makomo has joined #lisp
fikka has joined #lisp
X-Scale has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 276 seconds]
nicht has joined #lisp
brettgilio has quit [Remote host closed the connection]
potatonomicon has quit [Quit: blap]
btwiusemint has joined #lisp
fikka has joined #lisp
btwiusemint has quit [Client Quit]
<HighMemoryDaemon>
Can I pass one variable to "format" and do replacements in multiple places?
<HighMemoryDaemon>
Ex. something like (format t "~a and ~a" myvar)
<HighMemoryDaemon>
Where myvar would replace both instances.
<HighMemoryDaemon>
Don't want to pass the variable to format twice in this instance.
X-Scale has joined #lisp
<scymtym>
that would be (format t "~a and ~:*~a" myvar) where ~:* backs up one argument
<HighMemoryDaemon>
Oh cool!
<HighMemoryDaemon>
schjetne: Thanks! Works perfectly.
shka1 has quit [Ping timeout: 244 seconds]
<jasom>
skidd0: you can build an image within wine for making a windows executable
<jasom>
skidd0: i.e. install sbcl for windows inside wine, then do a save-lisp-and-die
<jasom>
windows is actually much easier than linux for this because if you depend on any DLLs you can just put them in the same directory (as that is in the default DLL search path)
pierpa has joined #lisp
JuanDaugherty has joined #lisp
<jasom>
as far as linux portability... the linux kernel has a very stable API, *but* the runtime will invariably depend on some dynamically linked shared objects, and possibly some dynamically loaded shared objects as well. This can pin executables to a very narrow set distributions (and a narrow set of versions within the distribution).
k-hos has joined #lisp
<skidd0>
i see, thanks jasom
<aeth>
jasom: That's nonsense. In practice, if you get a Linux application outside of a distro (or third party repositories that are intended for a certain distro) you're not going to depend on the distro's libraries.
scymtym has quit [Ping timeout: 276 seconds]
<aeth>
And such applications from 15 years ago can still run even if you don't recompile them.
JuanDaugherty has quit [Client Quit]
<aeth>
Although there might be issues with e.g. sound
<jasom>
Applications from 15 years ago will almost certainly not run due to glibc changes if nothing else.
<jasom>
oh, you are talking about applications with bundled libraries (or statically linked libraries)?
<aeth>
A properly written third party application that is neither source distributed nor distributed via a third party repository will bundle everything.
<jasom>
aeth: properly written third party applications are vanishingly rare then.
<aeth>
Then you're stuck with edge cases like having no sound, which I have experienced.
<aeth>
jasom: It's easier to do it these days.
<aeth>
There's middle ground methods like Flatpak.
<jasom>
most binary applications I've seen assume $TODAYS_POPULAR_LINUX_DISTRO e.g. Ubuntu today, redhat a while back.
wheelsucker has quit [Remote host closed the connection]
<jasom>
when did ld-linux.so start supporting paths relative to the executable?
<aeth>
Well, the ones that assume Ubuntu are probably increasingly using Snappy, whose only problem is that it's an Ubuntu-first NIH reinvention of something that exists not once but twice: AppImage and Flatpak.
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<aeth>
jasom: Anyway, I think the vast majority of proprietary software written for Linux at this point are Steam games that are written for the Steam for Linux runtime (or whatever it's called).
rumbler31 has joined #lisp
Smokitch has quit []
angavrilov has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
rumbler31 has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<copec>
I run a lot of arbitrary things with wine
k4rtik has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
LiamH has quit [Quit: Leaving.]
subroot has quit [Read error: Connection reset by peer]
Achylles has joined #lisp
scymtym has joined #lisp
Josh_2 has joined #lisp
Josh_2 has quit [Client Quit]
Josh_2 has joined #lisp
DonVlad has quit []
nicht has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Remote host closed the connection]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
red-dot has joined #lisp
Kundry_Wag has joined #lisp
pfdietz2 has joined #lisp
rpg has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
vlatkoB has quit [Remote host closed the connection]
rumbler31 has joined #lisp
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
kajo has quit [Ping timeout: 240 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
kajo has joined #lisp
xaotuk has quit [Quit: xaotuk]
jonh has left #lisp ["WeeChat 1.4"]
sjl_ has quit [Ping timeout: 268 seconds]
milanj__ has joined #lisp
Kundry_Wag has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
milanj_ has quit [Ping timeout: 268 seconds]
JuanitoJons has joined #lisp
moei has quit [Read error: Connection reset by peer]
Josh_2 has joined #lisp
moei has joined #lisp
shachaf_ has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
shachaf has quit [Disconnected by services]
shachaf_ is now known as shachaf
Bike has quit [Ping timeout: 252 seconds]
HighMemoryDaemon has quit [Remote host closed the connection]
Oladon has joined #lisp
acolarh has quit [Ping timeout: 264 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
acolarh has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
Josh_2 has joined #lisp
k4rtik has quit [Ping timeout: 245 seconds]
pfdietz2 has quit [Ping timeout: 276 seconds]
brettgilio has joined #lisp
Oladon has quit [Read error: Connection reset by peer]
housel has quit [Remote host closed the connection]
housel has joined #lisp
rumbler31 has joined #lisp
k4rtik has joined #lisp
<skidd0>
has anyone used CLON and experienced an issue with name conflicts?
<skidd0>
CLON has a symbol EXIT that conflicts with sbcl's SB-EXT:EXIT
fikka has quit [Ping timeout: 240 seconds]
<skidd0>
and it's not discussed in the quickstart example for CLON
<skidd0>
can I shadowing-import-from?
<skidd0>
is that what that's for?
rumbler31 has quit [Ping timeout: 276 seconds]
brettgilio has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
mange has joined #lisp
fikka has joined #lisp
Bike has joined #lisp
jfrancis has joined #lisp
jfrancis_ has joined #lisp
<jfrancis_>
Technically a slime question, not a CL question, but still relevant. Slime is getting angry because I'm getting a returned string containing non-UTF-8 characters. Specifically, I'm getting the error "Invalid protocol message: Error during string-to-utf8: Unable to encode character 55357 as :UTF-8.". That's all true and accurate. But I don't care. Is there any way to tell slime to show me anyway, and just go ahead and munge 55357 on my screen i
<jfrancis_>
nstead of throwing an error?
luis has quit [Ping timeout: 240 seconds]
jself has quit [Ping timeout: 248 seconds]
Ricchi has quit [Ping timeout: 245 seconds]
<Josh_2>
ignore-errors?
robotoad has quit [Quit: robotoad]
les has quit [Ping timeout: 260 seconds]
devn has quit [Ping timeout: 256 seconds]
emma has quit [Ping timeout: 240 seconds]
dlowe has quit [Ping timeout: 248 seconds]
anewuser has joined #lisp
jasmith has quit [Quit: Leaving]
<jfrancis_>
Mmm... You mean patch the slime source with an (ignore-errors ...) around the display code? I was hoping for something a bit less brute-force.
mfiano has quit [Ping timeout: 264 seconds]
warweasle has quit [Ping timeout: 276 seconds]
esthlos has quit [Ping timeout: 276 seconds]
anewuser has quit [Ping timeout: 244 seconds]
moei has quit [Quit: Leaving...]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
Josh_2 has joined #lisp
anewuser has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
orivej has joined #lisp
JuanitoJons has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
robotoad has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
nowhere_man has joined #lisp
rumbler31 has joined #lisp
red-dot has joined #lisp
karlosz has quit [Quit: karlosz]
esthlos has joined #lisp
dlowe has joined #lisp
Kaisyu has joined #lisp
fikka has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
Kaisyu72 has quit [Quit: ERC (IRC client for Emacs 25.3.2)]
Kaisyu7 has joined #lisp
<jasom>
skidd0: you can do shadowing-import-from; uiop also defines its own version of defpackage where you can do imports of packages with no conflicts order matters)