<aeth>
Does anyone configure their Emacs to highlight the types or classes green in places like defmethod?
<aeth>
Also probably would fit in THE and DECLARE as well as in quite a few custom DEFINE-FOO macros.
nowhere_man has quit [Ping timeout: 256 seconds]
<aeth>
it looks like if Emacs highlighted CL like it highlighted C++, (defmethod foobar ((something foo)) ...) should have something highlighted as yellow and foo highlighted as green instead of having no highlighting there.
nowhere_man has joined #lisp
<aeth>
It could be slightly problematic because &quux is green in all lambda-lists
lavaflow has joined #lisp
<aeth>
I have a bunch of custom define-foos and I use some libraries that have their own define-foos (or deffoos) so I'm considering writing some syntax highlighting, but defmethod stands out as not really fitting expected Emacs highlighting so I'm considering also doing highlighting for that.
lavaflow has quit [Ping timeout: 256 seconds]
Elon_Satoshi has quit [Quit: So long, and thanks for all the fish! 2.2 Weechat is best Weechat]
<PuercoPop>
cl-localtime has pretty flexible formatting output options
asarch has joined #lisp
<aeth>
I wrote my own ISO 8601 because it's mostly about taking DST into account... iirc, CL provides a multiple-values function that's basically a reversed ISO 8601 with the main difference being that ISO 8601 shifts the time zone with DST and CL keeps a constant time zone with a DST boolean
graphene has joined #lisp
<drmeister>
Thanks everyone.
<beach>
Good morning everyone!
ckonstanski has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
Bike has quit [Quit: Lost terminal]
housel has quit [Remote host closed the connection]
housel has joined #lisp
clog has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
hi beach
eminhi has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
<pjb>
<pjb>
aeth: Z is fixed GMT+0.
<pjb>
= UTC.
<asarch>
How could I create the binary of (ql:quickload "clim-examples") (CLIM-DEMO:DEMODEMO)?
<asarch>
...with SBCL?
<beach>
You could use save-lisp-and-die with the option of creating an executable file.
<asarch>
?
<asarch>
"For information on creating "standalone executables" using SBCL, see SB-EXT:SAVE-LISP-AND-DIE in the User Manual."
<beach>
Is there a problem?
siraben is now known as rms
rms is now known as siraben
buffergn0me has joined #lisp
<asarch>
No, sir no!
NoNumber has joined #lisp
Kundry_Wag has joined #lisp
\u is now known as meowray
<aeth>
pjb: Z is just yet another a special case, where you just put a conditional in the time zone name
<aeth>
it starts out as like 3 lines and is maybe 20 when you put all the special cases together
<aeth>
(two conditionals, actually. one to show Z if the offset is 0, another to force Z even if the CL time zone offset is not)
<asarch>
Why this?: "SYSTEM::%FIND-PACKAGE: There is no package with name "ASDF-USER""
<asarch>
?
<asarch>
However, the same quicklisp.list works fine with SBCL
<asarch>
*quicklisp.lisp file
slyrus1 has joined #lisp
<buffergn0me>
That sounds like an ASDF 2 thing. I remember reading somewhere there were problems with some of the old ASDF versions that came bundled with CLISP
ebrasca has joined #lisp
<asarch>
Oh :-(
<buffergn0me>
CLISP has not really been developed for a very long time
<asarch>
:'-(
<buffergn0me>
:shrugs: not a big deal, there are probably too many Common Lisp implementations even without CLISP. It wasn't that compelling to use it vs CCL or SBCL
<asarch>
Ok. I'll stick to SBCL
ckonstanski has quit [Quit: bye]
ebrasca has quit [Remote host closed the connection]
nonlinear is now known as NB0X-Matt-CA
ebrasca has joined #lisp
<beach>
buffergn0me: CLISP is being worked on right now, but it is still lagging behind because of several years of no activity.
Kundry_Wag has quit [Ping timeout: 256 seconds]
<buffergn0me>
Oh that's cool. New maintainers stepped up or is it still Bruno and Sam?
<beach>
I don't know the details, but I know that karlosz is working on a Cleavir-based compiler for CLISP as a Google Summer-of-Code project.
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
eminhi has quit [Remote host closed the connection]
moei has quit [Quit: Leaving...]
meepdeew has quit [Read error: Connection reset by peer]
gector has quit [Read error: Connection reset by peer]
meepdeew has joined #lisp
gector has joined #lisp
<siraben>
What are some good books on graphics (e.g. OpenGL, 2D graphics etc.) programming with Common Lisp?
<siraben>
Or resources.
<beach>
siraben: You may want to ask in #lispgames as well. They probably know more.
<mfiano>
The only one I know of is Land of Lisp, and I would not call it good. It is also wuite dated.
<siraben>
mfiano: Why is LoL not good?
<siraben>
beach: Ok I'll join that channel.
<mfiano>
I would consider that book a introduction to the language using impractical game development as a teaching aid.
montxero has joined #lisp
siraben has quit [Changing host]
siraben has joined #lisp
<siraben>
Oof, I was considering buying it.
<siraben>
Now I'm reading Practical Common Lisp
<siraben>
I think it's pretty good.
montxero has quit [Ping timeout: 264 seconds]
housel has quit [Remote host closed the connection]
zacts has quit [Quit: Konversation terminated!]
<buffergn0me>
Land of Lisp had almost no graphics in it
Khisanth has quit [Ping timeout: 268 seconds]
<siraben>
Right I've seen.
<siraben>
Emacs Lisp would be a good language to write games in, there's a couple already
<siraben>
tetris.el snake.el pong.el
<siraben>
But not for more complicated things with OpenGL
<beach>
What does Emacs Lisp have that Common Lisp does not?
<siraben>
It's made for Emacs
<siraben>
A lot of things in Emacs Lisp are taken directly from Common Lisp
<beach>
How does that make it suitable for games?
<siraben>
And prefixed with cl-
<siraben>
It does not, just a toy example
<siraben>
It's not suitable for games*
<siraben>
Just for simple demos I suppose
<beach>
You said "Emacs Lisp would be a good language to write games in"
<beach>
Hence my question.
<siraben>
Well, _some_ games
<beach>
So I meant to ask: What does Emacs Lisp have that Common Lisp does not, and that makes it a good language to write games in?
<siraben>
Well, perhaps I'm biased because the only games I've played written in Lisp were made in Emacs Lisp
<siraben>
But of course it's not the best Lisp
<beach>
I see.
<siraben>
Hence my interest in Common Lisp.
<siraben>
^esp wrt. OpenGL bindings
<beach>
It's not a trick question. I seriously wanted to know.
<siraben>
My bias, basically.
<siraben>
Haha
chipolux has quit [Quit: chipolux]
chipolux has joined #lisp
<buffergn0me>
Emacs Lisp is probably the last language you want to write games in. The Emacs event loop is horrible and there is no opting out of it.
<siraben>
Right.
Khisanth has joined #lisp
housel has joined #lisp
Kundry_Wag has joined #lisp
chipolux has quit [Quit: chipolux]
housel has quit [Remote host closed the connection]
sauvin has joined #lisp
housel has joined #lisp
bkst has quit [Quit: Lost terminal]
Inline has quit [Quit: Leaving]
Fare has quit [Ping timeout: 240 seconds]
chipolux has joined #lisp
buffergn0me has quit [Ping timeout: 240 seconds]
ebzzry has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
moei has joined #lisp
chipolux has quit [Quit: chipolux]
<aeth>
The only Lisp that's good for games is Common Lisp.
<aeth>
Nothing's stopping a Scheme from eventually getting there, though.
<aeth>
(Except maybe having a smaller community size)
<siraben>
Racket?
<siraben>
Well, in the Lisp Game Jam there was a lisp with lua support as well
<aeth>
You can make simple 2D games in any language. Compiling to Lua is kind of cheating... Lua is an entirely unsuitable language for games alone, but is built around being a scripting language for C. You could do this with almost any language, but Lua's the most popular for this because it's sandboxable.
<aeth>
You can make a game entirely in Common Lisp. The only barrier is lack of higher level libraries. (Making it entirely in Common Lisp is probably unwise, though. SDL will save you a lot of work porting to many OSes.)
<phoe>
aeth: higher-level libraries?
<siraben>
So I guess I'll attempt just learning OpenGL first and make some graphics with common lisp
<aeth>
You might *barely* be able to get Racket to run higher-performance games. I wouldn't be surprised if in the next year that becomes a lot easier, though.
<phoe>
siraben: #lispgames might help you with that
meepdeew has quit []
<aeth>
phoe: The most mature game libraries are pretty low level, relatively speaking.
<aeth>
at least at the moment
<aeth>
I think phoe might be working on one, though
<phoe>
me? how? where?
<aeth>
you're not?
<phoe>
nope, not really
<LdBeth>
Probably a C friendly CL should be used for this?
<phoe>
nothing strictly game-related.
buffergn0me has joined #lisp
<aeth>
LdBeth: If you don't care about footprint, SBCL + CFFI will be much faster, with CCL maybe half the speed in a worst case.
<aeth>
So if most of your game is in CL, those would be better choices
ofi has joined #lisp
nowhere_man has quit [Remote host closed the connection]
foom2 has joined #lisp
nowhere_man has joined #lisp
<phoe>
If MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION is the writer function, what's the respective reader function?
<aeth>
There are lots of simple 2D options. That seems to be the one that's currently the most actively developed.
<siraben>
aeth: I'll check it out, thanks.
<aeth>
There's just currently a big gap between simple 2D and raw OpenGL bindings.
buffergn0me has quit [Ping timeout: 240 seconds]
<aeth>
LdBeth: If an embeddable CL wanted to compete with Lua it would have to have sandboxing. Every game project starts with wanting to embed Python because of the popularity and then switching to Lua because Lua's pretty much the option for a tiny sandboxed language in C.
schweers has joined #lisp
<aeth>
phoe: oh one example of a higher level library that afaik is still lacking is a 3D physics one
<aeth>
Even bindings are hard because they're usually written in C++
<beach>
phoe: There isn't any.
<beach>
phoe: What do you need it for?
<beach>
phoe: For all practical purposes, the generic function *IS* the funcallable instance function.
aindilis has quit [Ping timeout: 240 seconds]
mathZ has quit [Remote host closed the connection]
<beach>
phoe: Hint: in SICL, there is actually no slot in the funcallable instance that stores the function given as an argument. Instead, it copies the components of the argument (i.e. the entry point in the code and the environment) to the funcallable instance component with the same function.
<beach>
phoe: Otherwise, there would be yet another indirection for the call.
<phoe>
beach: I don't need it for anything; curiosity, it's all.
<beach>
OK, now you know then. :)
<v0|d>
is it useful to have CL subset -> lua compiler?
<v0|d>
or does it exists already?
<beach>
What would you use it for?
<v0|d>
no idea, thats why Im asking.
<aeth>
v0|d: Lua is basically mini-JavaScript, and you use it for scripting for the same reason: lack of choice.
heisig has joined #lisp
<v0|d>
Interesting.
<aeth>
But anything using Lua is many orders of magnitude less popular and less important than a web browser.
<aeth>
(Pretty much everything but Microsoft Office is.)
<aeth>
I would not get my hopes up for a good CL->Lua when the two CL->JSes aren't very complete.
<v0|d>
Another question, why there is no attempt to build a SecurityManager/Context standard for CL? (sandboxing?)
<aeth>
that's a question for beach.
<beach>
v0|d: It is very hard to do with the existing implementations.
<v0|d>
aeth: thanks for the answer, much appreciated.
<beach>
v0|d: ... which is why I am creating an implementation in which it will be easier to accomplish.
test1600 has joined #lisp
<beach>
v0|d: The goal is to create a secure multi-user operating system. And I obviously can't let one user step on the code of other users, nor can I let random code from the net take down the entire system.
<v0|d>
Java has seperate class loader for each application.
<v0|d>
I always wondered how that might be applied to CL.
<v0|d>
GHC can also, load different versions of the same package.
<beach>
v0|d: I solve most of the problem with first-class global environments.
<v0|d>
See.
shrdlu68 has joined #lisp
<v0|d>
Lets say we are in CMUCL, we need two kernels or both two kernels/vms?
<beach>
They allow each user to have a separate default environment, and they allow the system to have its own, so that random code can not be used to hack the compiler (for instance).
<beach>
In a typical Common Lisp system, nothing prevents any programmer (or any code from the net) from modifying the compiler so that it generates code with (say) a virus in it.
<v0|d>
Its really not that silverlined for me for the particular case.
<beach>
What do you mean?
varjag has joined #lisp
<v0|d>
I mean, there is distinction of VM and KERNEL in CMUCL.
<v0|d>
I believe kernel is the subset that you were talking about.
<phoe>
not really
<phoe>
in Lisp, an environment describes what's accessible to you
<phoe>
what functions, what symbols, what objects, what everything
<phoe>
if you give an user an environment without access to the symbol CL:CAR, he won't be able to call #'CAR
<beach>
phoe: It's even better. I can give the user the symbol but not the function.
<phoe>
if you give an user an environment without access to any functions/macros/facilities that mutate anything, then he won't be able to mutate anything
<phoe>
beach: ooh
<phoe>
well, even better then
<beach>
Because in first-class global environments, functions are not attached to symbols but to the environment.
yangby has joined #lisp
<beach>
So I can even have different functions with the name CAR as long as they are in different environments.
<phoe>
v0|d: so, anyway, this isn't about VM or KERNEL, it's about what stuff you are allowed to access *by* the environment.
<phoe>
and most Lisp implementations have only one global environment per image, which is why they aren't really suited for multi-user environments.
msb has quit [Ping timeout: 248 seconds]
<v0|d>
Hm I guess I couldn't express myself properly.
<beach>
... or sandboxing.
<phoe>
which is why beach is currently working on an implementation where global environments are plentiful and you can jail/sandbox/lock a particular piece of code in an environment where it's unable to do harm.
<aeth>
I think it's not uncommon to run 3 Lisps at once.
uint has quit [Ping timeout: 248 seconds]
drot has quit [Ping timeout: 248 seconds]
kbtr has quit [Ping timeout: 248 seconds]
hvxgr has quit [Ping timeout: 248 seconds]
tralala has joined #lisp
<no-defun-allowed>
3 lisps means 3 times the speed, duh!
<phoe>
and three times the garbage collection
<shrdlu68>
But why not just have separate processes?
uint has joined #lisp
<beach>
no-defun-allowed: It also means that you have to communicate between them using this silly idea of converting everything to a stream of bytes, thereby losing identity of your objects.
kbtr has joined #lisp
hvxgr has joined #lisp
<Shinmera>
shrdlu68: Because communication is easier if it's in the same process.
<Shinmera>
shrdlu68: You can also share resources and conserve memory
drot has joined #lisp
<shrdlu68>
I see.
<v0|d>
Im interested in the code organisation of such a CL implementation.
<v0|d>
Like, which code will be shared among all?
<v0|d>
which cannot, assume I am the developer of that machine.
<v0|d>
I exactly know whats going to happen on the user side.
<no-defun-allowed>
beach: whoosh
<v0|d>
(not interesting)
<no-defun-allowed>
but yes, welcome to unix.
<phoe>
v0|d: it's not really about sharing; it's more about access.
<beach>
v0|d: Exactly what code will be shared is not easy to figure out. But certainly most standard functions will be shared, but they won't necessarily have the effect that they do in a typical Common Lisp implementation.
msb has joined #lisp
<phoe>
if an environment A has access to function FOO, then you can say that the code behind function FOO is "shared" with environment A.
<beach>
v0|d: I can't let (say) ADD-METHOD to add a method so that it is shared among all users of the generic function in question.
<v0|d>
Indeed.
<beach>
v0|d: So, either I give each one a separate generic function, or I store the methods in the environment rather than (as is usually the case) in the generic function object.
yangby has quit [Quit: Go out for a walk and buy a drink.]
<beach>
Stuff like that has to be decided on a case by case basis, but most cases will be very simple because they don't have any shared effect.
<beach>
... which just gave me an idea about how to do that. Thanks v0|d.
<v0|d>
Can it be done in the very low level? Don't laugh if it doesn't make sense. Lets say, a binary mmaps copies of some lisp image to the memory and executes each (top-level) in a sep. thread and implements a method of IPC.
<phoe>
v0|d: you mean the unix low-level?
<phoe>
or rather
<v0|d>
Sure.
<phoe>
"implements a method of IPC" the unix way, too?
<phoe>
meaning that you communicate via bytestreams?
<v0|d>
No, lisp IPC.
<v0|d>
we already have unix IPC.
<Shinmera>
beach: Could do COW, perhaps.
<phoe>
if we're in the Unix world, then we need Unix IPC between different processes
<phoe>
if these are threads and therefore share memory, then it could be done without inter-process bytestream communication
<phoe>
so, hmm, I can't see why this couldn't be done that way
<jackdaniel>
(because it is (quote (function foo))
<jackdaniel>
s/(because/because/
<phoe>
jackdaniel: well then, why (typep '(function foo) '(cons symbol (cons symbol null))) ;=> T?
<no-defun-allowed>
wait i see now
<phoe>
and why (typep '(function foo) '(cons (eql 'function) (cons symbol null))) ;=> NIL?
<no-defun-allowed>
(eql 'function) doesn't need the quote i think
<phoe>
gah
<phoe>
you are right
<phoe>
I knew it was some sorta silly mistake like that. (: thanks.
<no-defun-allowed>
np
<v0|d>
phoe: can I call you foo?
<v0|d>
or is it different.
<jackdaniel>
uhm, then I'm wrong it seems
<phoe>
phadthai: it's actually pronounced φ
<phoe>
jackdaniel: TYPEP destructures CONS; it's possible to describe a type that's "a list of three elements, the first two are floats and the third is a symbol" that way
<phoe>
as (cons float (cons float (cons symbol nil)))
<no-defun-allowed>
got phi problems?
<phoe>
uh, woops
asarch has quit [Quit: Leaving]
<phoe>
phadthai: sorry
<phoe>
v0|d: ^
yangby has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<phadthai>
no problem phoe :)
Kundry_Wag has joined #lisp
<hjudt>
what would i have to do to add keywords to a slot definition and to access this later? e.g. specifying a serialization function
vlatkoB has joined #lisp
<phoe>
hjudt: sounds like creating a custom slot definition metaobject
<Shinmera>
Doing so is quite involved though
<hjudt>
yes probably
<hjudt>
ok so nothing easy?
<phoe>
nothing trivial
<Shinmera>
Let me see if I can dig up an example in my code base that's somewhat comprehensive
<phoe>
and nothing easy unless you have some MOP experience
<hjudt>
examples would be helpful, or maybe something to read
<Shinmera>
The above allows you to specify a type initarg on slots that is strictly checked (unlike the standard :type which may or may not be used for anything)
<hjudt>
ok thanks seems like a good starting point. but also looks like quite a bit customization is needed... as you said not trivial
<Shinmera>
The MOP requires quite a bit of boilerplate.
<hjudt>
and understanding of the mop
<Shinmera>
Ah, that part's not so hard once you understand that it's classes all the way down :)
<phoe>
until you reach turtles
robotoad has quit [Quit: robotoad]
<hjudt>
i will delve in some time later when i don't have work to do and it is not so hot outside and inside ;-)
DataLinkDroid has joined #lisp
yangby has quit [Quit: Go out for a walk and buy a drink.]
samebchase has quit [Quit: WeeChat 1.6]
tralala has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
samebchase has joined #lisp
tralala has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
nowhere_man has quit [Ping timeout: 256 seconds]
aindilis has joined #lisp
figurelisp has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
Bronsa has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
dddddd has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
orivej has joined #lisp
test1600 has quit [Ping timeout: 240 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
graphene has quit [Remote host closed the connection]
ismdeep has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
<jeosol>
I have a question related to cl-store. I have a defclass and after some calculations, I serialize it to a file. But when I tried to read it back into a session (via cl-store:restore ..), I get an invalid function: (lambda () :in some-function-name ..)
<jeosol>
above, I meant serialize an instance of the class ...
<phoe>
jeosol: can you paste the full error that you get?
graphene has joined #lisp
<jeosol>
thanks.
graphene has quit [Remote host closed the connection]
<siraben>
borodust: No worries. Glad I had IRC to help.
<borodust>
siraben: 👍
black_13 has joined #lisp
<jeosol>
what is the correct way to return a closure(?) around a function, so that I just call the function later, e.g., (funcall func-name). For a simple example (not actual case but similar) I define a function like (defun make-random () #'(lambda () (random 100.0)))
<jeosol>
and then use it later elsewhere like (funcall (make-random))
<jeosol>
shrdlu68: thanks it's similar to what I currently do. The problem is I am getting a cl-restore related problem that some function (make-random in the above example) is invalid function name
<shrdlu68>
Perhaps it expects a function name, not a function object.
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<v0|d>
diff btw 'make-random and #'make-random prob.
nowhere_man has joined #lisp
panji has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
trittweiler has quit [Ping timeout: 240 seconds]
<phoe>
jeosol: return a closure? what do you mean?
<phoe>
does CL-STORE allow serializing functions at all?
random-nick has quit [Read error: Connection reset by peer]
azimut has quit [Ping timeout: 265 seconds]
<pjb>
v0|d: yes, it would be interesting to have various CL->x translators, so CL programmers can use those systems without suffering the pain of programming or scripting in those bullshit languages. lua might be nice, but it's not CL. Now, of course, since there is already a lot of code written in x, you would also want a x->CL translator, so that a CL programmer can maintain or patch those scripts. This is why I started a lua scanne
random-nick has joined #lisp
<Shinmera>
pjb: your IRC client ate the rest of your message
<pjb>
beach: I would used a Lua->CL->Lua translator pair to write scripts in the DCS World simulator. (but lua is used in a lot of games).
<pjb>
Usually they just send another message; is there an option in erc?
<pjb>
Now, of course, since there is already a lot of code written in x, you would also want a x->CL translator, so that a CL programmer can maintain or patch those scripts. This is why I started a lua scanner and parser a few years ago.
<pjb>
shrdlu68: notice that unix processes, ie. separate addressing spaces, where invented because in unix we want to run uncontrolled programs, written in assembler, or later, in C, and having free access to all the hardware and processor instructions.
<pjb>
Clearly, this leads to constant crashes (just like any C program), so we need hardware support to implement this separation of addressing spaces and privilege rings.
<pjb>
shrdlu68: but this is a patch on a peg leg.
<pjb>
shrdlu68: other systems give protection at a finer level, and this is possible cheaply in a controlled execution environment, with the help of a compiler that forbid the generation of random code such as address calculations.
<pjb>
In those systems, there will be no FFI!
<pjb>
shrdlu68: you might be interested in studying http://eros-os.org or keykos (or some older systems such as Burrough's).
eschatologist has quit [Ping timeout: 244 seconds]
<makomo>
hello \o
<pjb>
jeosol: the operator that creates closures is CL:FUNCTION !
<pjb>
jeosol: In (defun make-random () #'(lambda () (random 100.0))) #'(lambda () (random 100.0)) reads as (CL:FUNCTION (lambda () (random 100.0))) and this is what creates the closure returned by make-random.
<pjb>
jeosol: note however that dynamic bindings (special variables) cannot be enclosed in closures, since closures are a lexical (spatial) notion, while dynamic binding is a temporal notion.
<foom2>
pjb: unfortunately, we now know that our *hardware* requires address-space separation for security, even if the software guarantees that it never generates machine code that would expose incorrect privileges.
<pjb>
foom2: how do you know that?
<foom2>
pjb: all the research papers on spectre and the follow-ons to it.
<pjb>
IIRC, spectre is a bug in the MMU? Without MMU, no spectre right?
<foom2>
Nothing to do with MMU. And it's not a "bug" per se, it's a giant hole in the models of machine behavior.
<foom2>
Let's say you have an array. Your programming language is not C, so it obviously checks that the element you're accessing is within the array, right?
<beach>
foom2: Sure.
<foom2>
Well, the hardware doesn't care, it speculatively assumes that the element is within the array, and loads the offset anyways. You don't get to see the result of that load, because the speculation is discarded, but it causes side-effects -- a cache line was loaded.
Kundry_Wag has quit [Ping timeout: 240 seconds]
<beach>
So how do you exploit that?
<foom2>
And then you can observe that side-effect by comparing performance of a future fetch.
<beach>
And what will you conclude from that performance difference?
<phoe>
You basically iterate over a large amount of possible values and check the access times for them. For some value, this time is going to be smaller, since the value was cached by the CPU.
<jmercouris>
if we could somehow make it such that nobody had the desire to hurt anyone else in society, we wouldn't have to struggle with this constant exploit battle
<phoe>
By iterating enough times, you get a statistical time profile that's good enough for you to extract information from.
<jmercouris>
when I say society, I mean the greater global society
mindCrime has quit [Ping timeout: 256 seconds]
<beach>
foom2: I was hoping you would summarize it so that I don't have to read it. I tried to understand it in the past and failed.
orivej has joined #lisp
<phoe>
beach: I'm trying to help a little bit. (:
<foom2>
beach: okay, so, you want to discover what some value in memory is, that you're not allowed to access.
<beach>
OK.
<foom2>
beach: basically, what you want to be able to do is to speculatively load the value, then speculatively run some math instructions (e.g. mask off bits, say) on the result of that, then a second load.
<beach>
OK so far.
<foom2>
The second load will tell you whether the bit you masked off was 0 or 1, by which cacheline it pulled in.
<Bike>
that's the part i don't understand :(
<beach>
So the result of the masking is an address you use for the second load?
<beach>
Well, the latest scare about x86 processors having all kinds of DRM stuff on them has made me a lot more interested in RISC-V.
shrdlu68 has quit [Ping timeout: 240 seconds]
pierpal has joined #lisp
<foom2>
It reportedly "only" causes an ~30% slowdown, with some compromises that make it not 100% complete protection.
<Bike>
the economics of making chips seem to favor oligopolies, which are pretty vulnerable to Management Engine type stuff. it is, to say the least, unfortunate
<beach>
Indeed.
<pjb>
jmercouris: Current events teach us again that the greater global society doesn't exist: it's life, it's competition, it's darwin selection of the best.
<phoe>
well, x86_64 chips are on computers everywhere that are used to watch Hollywood videos, so it's obvious that Hollywood wants DRM on them, eh
<Shinmera>
Producing chips is unfortunately extremely expensive :/
<beach>
I also read a paper recently about how impressively simple it was for a chip manufacturer, without the knowledge of the chip DESIGNER, to introduce a back door into a chip. And it would be very hard to detect such an addition.
<pjb>
jmercouris: the only context (society) where it's possible is within a "family" or the equivalent country wide: strong ethnic homogeneity.
<Bike>
cripes.
<beach>
This seems like a good time to take a break.
NB0X-Matt-CA has quit [Excess Flood]
Bike has left #lisp [#lisp]
<phoe>
I recently deleted all Lisp code I wrote for a library when I realized that it was essentially useless
NB0X-Matt-CA has joined #lisp
<loke>
phoe: What code was it?
<phoe>
which was pretty darn good - I'd never have realized that without writing all that code.
<phoe>
loke: code for implementing a Petri net library.
<loke>
phoe: what is that?
<phoe>
I realized that I 1) wrote too much error handling code, 2) the objects I had were essentially functions, and were fully replaceable by them.
<phoe>
and (foo) is something that isn't available in the cache.
<pjb>
That seems to me to be really a big design error.
<pjb>
(in the processor).
<phoe>
pjb: well, it is.
<foom2>
It's fundamental to the entire concept of caching and speculation.
<foom2>
It's not a big _design_ error, it's a really big conceptual error in the entire way we've thought about creating processors for the last few decades.
<pjb>
Ah, right, you're making only read access in the array, no write access. So it can keep executing as long as you're only reading and the data is available.
<foom2>
You can speculate writes too, fwiw.
rpg has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<phoe>
These writes will never leave the CPU because the speculation is discarded and not committed, but you can read the associated side effects of the CPU's inner work by means of timing.
<pjb>
Well, in any case having some cooperation between the hardware and the software is indeed a prerequisite for security and safety.
<pjb>
In the worst case, if you're running on a virtual machine, anything can happen under your feet.
<jeosol>
phoe, pjb, v0|d: thanks for the inputs. I had to get sleep to rest the brain. I think the issue is related to how I returned the function.
hiroaki has quit [Ping timeout: 240 seconds]
<jeosol>
phoe: my use of use of closure(?) is technically not correct. My bad. I have a utility similar to the make-random example. I serialize to disk on, but on reading it back, it complains about that function.
ofi has quit [Remote host closed the connection]
X-Scale has quit [Ping timeout: 240 seconds]
sauvin has quit [Ping timeout: 268 seconds]
<pjb>
jeosol: indeed, functions and closures cannot be serialized by PRINT/READ. functions can be serialized by COMPILE-FILE/LOAD, but not closures.
<pjb>
jeosol: the problem with closures is that there may be several functions inside, and we'd have to load them at once. So this is not specified.
<pjb>
jeosol: if you need to do that in lisp, you can always save the values of your bindings, and the source of the functions.
iridioid has joined #lisp
azimut has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<jeosol>
pjb: really? hmmm. I save that function to a slot of a defclass that I call later. It's like, there are different distributions (normal, uniform), one is chosen at the start of the program, it is saved in a slot for later use throughout the run
<jeosol>
pjb: from your comments, it seems I have to think about this differently. It's expensive to generate the objects again (> 4hours run), hence my choice of trying to save and read-in
<phoe>
which kinds of objects are you generating?
<phoe>
if you're generating data, can't you try to serialize this alone, and recreate the closure using that data later on
<jeosol>
phoe: pardon the wrong use of word/terms. I am running an application that takes anywhere from 4 to 7 hours (worst case), and I have to save certain information about state (pressures, rates, etc) within some object.
chipolux has joined #lisp
<phoe>
within that object, correct. If that object is some kind of standard-object, it should be serializable, depending on what is inside its slots.
<jeosol>
I do something like (defmethod run-object (obj class) ...), when I call (run-object obj ...), the object is updated with lots of info.
AnLog has joined #lisp
<phoe>
Yep, I see. What makes OBJ non-serializable, then?
<jeosol>
phoe: yes, that is what I thought. I think I have been able to read-in and back before, but not sure of the current before, but this was before many addition updates.
quipa has joined #lisp
<phoe>
jeosol: what makes that object non-serializable? Do you refer to any lambdas and/or closures from inside it?
sauvin has joined #lisp
rippa has joined #lisp
<jeosol>
phoe: short answer is yes, I think I am using that (I need to save a generator for a distribution (e.g., normal, uniform, etc), and this is saved in a slot for one of the object.
FreeBirdLjj has joined #lisp
<phoe>
jeosol: can you regenerate this generator after the object is deserialized?
<phoe>
or rather
<jeosol>
phoe: there are many workflows, but current one doesn't even call or use the generator, but that slot still had some value for the generator. Perhaps, I need to remove it and test in isolation.
<phoe>
can you DEFUN that generator and just store the symbol inside that slot? Funcalling that symbol will be equivalent to funcalling the function object associated with it.
<jeosol>
phoe: that will be a yes,
<phoe>
jeosol: do that, then!
<jeosol>
because it just takes a list to sample from.
<jeosol>
let me try these options and see.
slyrus1 has quit [Quit: slyrus1]
Achylles has joined #lisp
<pjb>
jeosol: you can put in the closure functions to serialize and deserialize it.
<pjb>
and then, random-states cannot be serialized (conformingly: ecl and abcl cannot do it).
<pjb>
See previous discussions about the subject: write your own random number generator so you may save the state.
<jeosol>
pjb: thanks for that info. seems
<jeosol>
I will try to expand this a bit so it's clear. The random number example was to simplify my case.
<jeosol>
I will make a quick paste now.
<pjb>
or use an implementation that can save it: (unless (ignore-errors (read-from-string (prin1-to-string *random-state*))) (error "Choose another implementation, able to serialize random states"))
<phoe>
` Implementations are required to provide a read syntax for objects of type random-state, but the specific nature of that syntax is implementation-dependent. `
<phoe>
all implementations are able to serialize random states.
<jeosol>
now, the discrete-variable-generator is used in the specific workflow I ran, but when I try to serialize back the object, I get invalid function name: (lambda () :in discrete-variable-generator)
<jeosol>
or i need some rest, hmm
slyrus1 has joined #lisp
buffergn0me has joined #lisp
<pjb>
ok, so abcl and ecl have a conformity bug here.
graphene has quit [Remote host closed the connection]
figurelisp has quit [Quit: Lost terminal]
<phoe>
huh?
<phoe>
(let ((*print-readably* t)) (print *random-state*)) works on ECL
<phoe>
wy
<phoe>
oops, wrong tab
graphene has joined #lisp
zacts has quit [Quit: Konversation terminated!]
zacts has joined #lisp
Copenhagen_Bram has quit [Read error: Connection reset by peer]
<pjb>
jeosol: but note that your closures ignore *random-state*.
<pjb>
therefore you won't have reproducible runs.
<phoe>
pjb: what kind of bug?
Copenhagen_Bram has joined #lisp
<pjb>
phoe: indeed, *random-state* can be printed readably in ecl. I don't know why they don't print it readably in all cases. Remains abcl which doesn't print it readably: Armed Bear Common Lisp #<RANDOM-STATE {28316DC4}> cannot be printed readably.
varjag has joined #lisp
<phoe>
ooh, that's a bug then
<jeosol>
pjb: yes, good point. That would be good to have, but in general, they are optimization runs, and I average results from multiple runs to get an average performance.
<pjb>
phoe: when an implementation diverge from the specified behavior, it's not conforming, it's a bug of the kind conformity bug.
<phoe>
pjb: yes, agreed
mkolenda has joined #lisp
schweers has quit [Ping timeout: 240 seconds]
<pjb>
jeosol: that's not the point. the point is that when you deal with pseudo random numbers, you often want to be able to reproduce an identical run (eg. to be able to debug a bug occuring only in some specific case).
<jeosol>
pjb: thanks for the paste, need to study it and adapt it to my case. Only different I see at a high-level is that the object being serialized contains the generator.
vaporatorius has quit [Quit: Leaving]
zacts has quit [Quit: Konversation terminated!]
<pjb>
jeosol: no, the serialized string only contains the names.
<jeosol>
pjb: my comment was not to disagree with you. Yes, that is a valid
<pjb>
(and instructions to recreate the generator).
<pjb>
jeosol: of course, this is recursive; this works only because the data bound inside the closure is printable readably.
nika has joined #lisp
shka_ has joined #lisp
<jeosol>
jpb: most of my cases are discrete parameters (numbers, or string)
<pjb>
Yes, in general the set of types printable readably is enough for practical purposes. And it's easy to add your own serialization if needed. See make-load-form (for saving in a fasl) and print-object.
<jeosol>
pjb: something I see from your snippet. Could my use of cl:restore be the issue here. Perhaps may be try another method to serialize and deserialize the object
<pjb>
what is cl:restore?
<phoe>
pjb: cl-restore
<jeosol>
sorry,
<jeosol>
cl-store library
<phoe>
a function from the CL-STORE serialization library
<jeosol>
cl-store:restore ...
<jeosol>
(cl-store:restore ...)
<pjb>
No, you can use it instead of prin1 and read.
<pjb>
and format.
<jeosol>
I serialize with (cl-store:store object filename) then read back with (cl-store:restore filename)
<pjb>
Yes. That's good. Only you must include the names.
<jeosol>
you mean the names of the options
<jmercouris>
so I have a very large sqlite database on a remote server, anyone know how it would be possible to connect with cl-dbi to that database?? or any other tool or combination of tools?
<jmercouris>
of course I could SSH onto the machine, install lisp, and then start working, but the latency of SSH and constantly repushing code to the server is frustrating
<jeosol>
jermcouris: mito?
<jeosol>
sorry, about that, different application
Kundry_Wag has quit [Ping timeout: 244 seconds]
<jmercouris>
its ok, mito also uses cl-dbi underneath
<jmercouris>
I thought about converting the database to mysql or something and then connecting to it
<jmercouris>
but that is a huge operation, and I have to know if there is a simpler way first
mkolenda has quit [Remote host closed the connection]
<jeosol>
Well, I have used mostly postgresql with mito, and clsql, but sqlite3 with clsql.
<jmercouris>
I see
<jeosol>
btw, i see your clml comments above. I'll love to hear your experiences with the library.
<jmercouris>
I finally did get it working, but not with quicklisp
X-Scale has joined #lisp
zacts has joined #lisp
<jmercouris>
I'll let you know if I end up forking it as we had discussed
aindilis has joined #lisp
<jeosol>
that may be the way to go. it was a bit messy, when I wanted to run the clustering algorithms. I meant the package organizations.
<jmercouris>
yeah, its very messy
buffergn0me has quit [Ping timeout: 240 seconds]
iridioid has quit [Ping timeout: 240 seconds]
buffergn0me has joined #lisp
iridioid has joined #lisp
charh has quit [Ping timeout: 256 seconds]
<pjb>
jeosol: I mean the enclosed values.
slyrus1 has joined #lisp
<pjb>
ie. the values bound to enclosed variables.
<pjb>
jmercouris: open a ssh tunnel, and connect thru it.
zacts has quit [Quit: Konversation terminated!]
<pjb>
ssh database.server -L ${dbport}:localhost:${dbport} & and connect to the database localhost:${dbport}
nsrahmad has joined #lisp
light2yellow has quit [Ping timeout: 240 seconds]
<jmercouris>
I don't see how that would work
<jeosol>
pjb, phoe, and others: thanks for your help. I fixed the problem, albeit partially for now. I decided to save the list of the options and call the function explicitly.
<jmercouris>
sqlite3 operates on a file descriptor, not a port
pierpal has quit [Quit: Poof]
light2yellow has joined #lisp
pierpal has joined #lisp
<Shinmera>
There's sshfs but it's pretty slow
<jeosol>
pjb: I'll explore the robust option you suggested. I'll just recall, that I save the random-state used for a given run.
<jmercouris>
sshfs is indeed too slow :\
<jmercouris>
I think my only real option is pushing my source to the server and having a remote slime connect in which I reload the system after every big code change
<jmercouris>
but that still makes it complex to test on the actual data, so I'll have to copy the schema from the sqlite3 database locally and insert some small amount of dummy data
Jesin has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 244 seconds]
<pjb>
jmercouris: the point is that you'd want to encrypt the communications with the remote database, so using a ssh tunnel is an easy solution to do that.
<jmercouris>
that is an easy solution
<jmercouris>
I'm just going to go buy a large external hard drive
<jmercouris>
there is no other way
<pjb>
yep, hard disks are cheap.
nowhere_man has joined #lisp
<jmercouris>
if it saves me hours of effort in testing the data set, it is worth it
housel has quit [Read error: Connection reset by peer]
<jeosol>
jmercouris: do you mean you are sending that remotely?
<jeosol>
I had a similar problem to yours, eventually, I had the data copy on the remote machine. I push code changes to the remote machine and run it there.
<jmercouris>
yeah, that is what I will do
<jeosol>
I have same setup as my local machine.
<jmercouris>
but I will make a small toy-database just for a sanity check on my local machine
<jeosol>
it's a bit painful, but in the future, when I have time, I will use the docker, ansible routes etc, when I need to duplicate machines
<jmercouris>
I may also buy the hard drive as well, just because
<jeosol>
that makes sense
<jeosol>
I did explore the database option for my case, it was taken a lot of time to even write the data to the database (many large arrays) and then having the application read it back in.
nsrahmad has left #lisp ["Leaving"]
<gendl>
Can emacs establish an ssh tunnel to a remote Linux host running Lisp, in order to do a swank connection?
<gendl>
I mean for example emacs running on Windows, can it do something like a
<gendl>
ssh -L8042:localhost:8042 my-dev-host
<gendl>
automatically self-contained from inside emacs,
<gendl>
or would the person have to run some kind of shell manually and to that ssh first, before being able to do M-x slime-connect to connect through the localhost tunnel to my-dev-host?
FreeBirdLjj has joined #lisp
housel has joined #lisp
<jmercouris>
gendl: emacs itself could open the ssh tunnel
zacts has joined #lisp
gector has quit [Read error: Connection reset by peer]
captgector has joined #lisp
Tristam has quit [Quit: Leaving]
<pjb>
gendl: emacs can open ssh tunnels with tramp. But that code is not used by slime. This could be a nice contribution to slime.
<pjb>
For now, you need to type M-x shell RET ssh -L80342:localhost:8042 my-dev-host RET
<gendl>
pjb: and that assumes the local machine has ssh installed, right? (i.e. ssh isn't built into emacs somehow, is it?)
<gendl>
especially this is an issue of local machine is a Windows one.
buffergn0me has quit [Ping timeout: 240 seconds]
<pjb>
You could use (make-process :name "ssh for slime" :buffer (get-buffer-create "*ssh for slime*) :command "ssh -L80342:localhost:8042 my-dev-host") to launch it automatically.
<_death>
gendl: I wrote an ssh-tunnels module some years ago.. you can find it in melpa
<pjb>
you could call it from a :before advice of slime-connect
trittweiler has joined #lisp
jmercouris has quit [Ping timeout: 240 seconds]
wigust has joined #lisp
Jesin has joined #lisp
siraben has quit [Ping timeout: 240 seconds]
lavaflow has joined #lisp
X-Scale has quit [Ping timeout: 244 seconds]
test1600 has joined #lisp
m00natic has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
pjb has quit [Read error: Connection reset by peer]
graphene has quit [Read error: Connection reset by peer]
iridioid has quit [Ping timeout: 244 seconds]
pjb has joined #lisp
iridioid has joined #lisp
tomaw has quit [Read error: Connection reset by peer]
tomaw has joined #lisp
asarch has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
X-Scale has joined #lisp
scottj has joined #lisp
test1600_ has joined #lisp
test1600 has quit [Ping timeout: 240 seconds]
smaster has joined #lisp
iridioid has quit [Read error: Connection reset by peer]
test1600_ has quit [Ping timeout: 256 seconds]
sauvin has quit [Remote host closed the connection]
anewuser has joined #lisp
Jesin has quit [Read error: Connection reset by peer]
Jesin has joined #lisp
JuanDaugherty has joined #lisp
Tristam has joined #lisp
zotan has joined #lisp
meepdeew has joined #lisp
quipa has joined #lisp
papachan has joined #lisp
nanthil has quit [Quit: Page closed]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
zacts has quit [Quit: Konversation terminated!]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<gendl>
dim: Thanks.
nowhere_man has quit [Read error: Connection reset by peer]
Achylles has quit [Quit: Leaving]
pierpal has quit [Quit: Poof]
shka_ has quit [Ping timeout: 256 seconds]
pierpal has joined #lisp
kamog has quit [Quit: Leaving.]
smaster has quit [Ping timeout: 276 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
mkolenda has joined #lisp
vlatkoB has quit [Remote host closed the connection]
pierpa has joined #lisp
nowhere_man has joined #lisp
zotan has quit [Excess Flood]
zotan has joined #lisp
orivej has joined #lisp
smaster has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
gravicappa has quit [Ping timeout: 260 seconds]
eschatologist has quit [Ping timeout: 244 seconds]
eschatologist has joined #lisp
kajo has joined #lisp
hph^ has quit [Ping timeout: 264 seconds]
hiroaki has joined #lisp
Fare has quit [Ping timeout: 240 seconds]
evilbot23 has quit [Read error: No route to host]
Zhivago has quit [Read error: No route to host]
jkordani has quit [Read error: Connection reset by peer]
jmercouris has joined #lisp
hiroaki has quit [Ping timeout: 265 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
smaster has quit [Ping timeout: 244 seconds]
smaster has joined #lisp
hiroaki has joined #lisp
Fare has joined #lisp
quipa has quit [Quit: Leaving]
slyrus has quit [Quit: slyrus]
slyrus1 is now known as slyrus
slyrus1 has joined #lisp
<jmercouris>
anyone know of a js/css minifier written in CL?
<AeroNotix>
If I've DECLAIM'd something. How can I undo that declaim?
<AeroNotix>
I declaimed an ftype that is impossible
<Shinmera>
jmercouris: LASS can output to minified CSS, but it doesn't have a CSS->LASS compiler, so it's only half the answer.
<jmercouris>
Shinmera: I've seen other similar projects, I don't want to write my CSS in S-expr, but maybe I'll have to, either that or write a minifier myself
<AeroNotix>
Redeclaring the type, works. But I would've expected a way to unset the type declare
<AeroNotix>
declaim*
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
jmercouris has quit [Remote host closed the connection]
<pierpa>
you can unintern the symbol you declaimed about, and then reload all the users.
rumbler31 has joined #lisp
<White_Flame>
Everything has an assumed default declaration, and many Lisp operations (like DEFUN) destructively modify their scope
<White_Flame>
so its prior state is gone. re-DECLAIMing is a proper solution
<pierpa>
*unintern the symbol, create a new one, apply the right declamation, reload users...
<White_Flame>
sure, if you're wholesale reconstructing, as opposed to fixing a recently misapplied declaration
<pierpa>
I'm assuming the symbol with the wrong declamation has been used somewhere
<White_Flame>
I also personally think it's good form to ensure you can cleanly reconstruct your environment from source consistently, as opposed to just carrying forward random image state
<White_Flame>
so some of those smaller fixups may or may not apply
<pierpa>
I prefer both to ensure I can cleanly reconstruct my environment AND also apply small fixes in the image
rumbler31 has quit [Ping timeout: 244 seconds]
patlv has joined #lisp
jusss has joined #lisp
<jusss>
(3) is a pair (3 . ())
Fare has quit [Ping timeout: 256 seconds]
Fare has joined #lisp
<pjb>
It's also a list. (ie. either a pair or nil).
<jusss>
(() ()) how to detect that is end of the list?
<pjb>
It's also a proper list. (ie. a list whose cdr-chain ends in nil).
<pjb>
Note, often people use null to test the end of list, but this is not correct, because in case if dotted list, null returns always false, and the else branch will try to process the atom as if it was a pair.
<AeroNotix>
White_Flame: From source it _would_ have been able to be reconstructed cleanly. During development buggy code can be executed and then fixed.
<AeroNotix>
Only I didn't want to restart my slime session but I wanted to know how to roll that declaim back
<jusss>
like (3 5) in loop, we can detect that (cddr (3 5)) to know the list is over, what the list is (() ())? because (cdr (() ())) is same as (cdr (()))
<pjb>
jusss: (3 5) is not a valid form.
<pjb>
jusss: (cddr (3 5)) is a program-error.
<pjb>
(cddr (3 5)) #| ERROR: Car of (3 5) is not a function name or lambda-expression. |#
<pjb>
(equalp (cdr '(() ())) (cdr '(()))) #| --> nil |# they're not the same.
<pjb>
jusss: you're not prudent, you're saying silly things that even your REPL know better!
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
<jusss>
(cdr ‘(()))
<White_Flame>
AeroNotix: yeah, and reconstruction means that any hot-fixes and initialization you made to get it working must move into your source code, which is a good thing.
lel has joined #lisp
ravndal has quit [Quit: WeeChat 2.2]
lel_ has quit [Ping timeout: 264 seconds]
<AeroNotix>
White_Flame: it's just good to know how to "manually" fix the issue without restarting the current session. Actually I did restart it, for a similar kind of issue (I suspected more so I didn't want to fight it any longer)
<White_Flame>
sure
ravndal has joined #lisp
<White_Flame>
it's a heck of a lot easier than the other-languages edit/compile/run cycle ;)
Kundry_Wag has joined #lisp
patlv has joined #lisp
<AeroNotix>
for sure
jusss has quit [Remote host closed the connection]
<AeroNotix>
Even languages touted as having a "live" or "runtime recompilable" environment, like Erlang.
<AeroNotix>
CL far outperforms
random-nick has quit [Ping timeout: 256 seconds]
patlv has quit [Remote host closed the connection]
mange has joined #lisp
jusss has joined #lisp
patlv has joined #lisp
shlecta has joined #lisp
patlv_ has joined #lisp
koenig1 has joined #lisp
energizer_ has joined #lisp
sword` has joined #lisp
<aeth>
What about Smalltalk?
uint_ has joined #lisp
lemoinem has quit [Killed (tolkien.freenode.net (Nickname regained by services))]
<AeroNotix>
aeth: never used it personally. It's on my List.
<aeth>
Personally, I put languages on my adjustable vector instead of a list.
azrazalea has joined #lisp
\u has joined #lisp
drdo_ has joined #lisp
<AeroNotix>
There aren't that many I'm interested in that I need to microoptimize like that
<aeth>
I haven't tried Smalltalk yet, either, because I think the most mature environments are commercial environments. I'd like to see how it compares to Emacs+SLIME though.
patlv has quit [*.net *.split]
smaster has quit [*.net *.split]
zotan has quit [*.net *.split]
jusss has quit [*.net *.split]
papachan has quit [*.net *.split]
Tristam has quit [*.net *.split]
uint has quit [*.net *.split]
dlowe has quit [*.net *.split]
meowray has quit [*.net *.split]
dan64 has quit [*.net *.split]
iskander has quit [*.net *.split]
azrazalea_ has quit [*.net *.split]
drdo has quit [*.net *.split]
hvxgr__ has quit [*.net *.split]
koenig has quit [*.net *.split]
Xach has quit [*.net *.split]
Xof has quit [*.net *.split]
sword has quit [*.net *.split]
Lord_Nightmare has quit [*.net *.split]
bend3r_ has quit [*.net *.split]
snits_ has quit [*.net *.split]
mrSpec has quit [*.net *.split]
djh has quit [*.net *.split]
energizer has quit [*.net *.split]
guaqua has quit [*.net *.split]
Mandus has quit [*.net *.split]
n3t has quit [*.net *.split]
tkd has quit [*.net *.split]
drdo_ is now known as drdo
Lord_Nightmare2 has joined #lisp
<AeroNotix>
aeth: and there's my main issue with it. If it doesn't integrate with emacs it'll take me a lot longer to care about it.
<AeroNotix>
$PREVIOUS_DAY_JOB had a lot of Java in place which I could have contributed to but the whole ecosystem is just complete garbage
Lord_Nightmare2 is now known as Lord_Nightmare
Mandus has joined #lisp
Denommus has quit [Remote host closed the connection]
Tristam has joined #lisp
shlecta has quit [Ping timeout: 240 seconds]
patlv_ has quit [Ping timeout: 244 seconds]
<pjb>
AeroNotix: you can write unix programs in Smalltalk in emacs using gst.
<aeth>
Writing Smalltalk outside of a written-in-and-for-Smalltalk IDE would be like writing CL outside of a written-in-and-for CL IDE.
chipolux has quit [Client Quit]
chipolux has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
<aeth>
Of course even if such an IDE existed, you'd have the strange situation where you'd be running three copies of CL: one for stumpwm, one for the editor, and one for the inferior-lisp (you wouldn't want to mix the latter two because sometimes you get into a state where M-x slime-restart-inferior-lisp is the simplest solution)
shlecta has joined #lisp
energizer_ is now known as energizer
kajo has joined #lisp
<aeth>
(you'd also want to be able to run a CL implementation that's not the same as the editor's)
robotoad has quit [Quit: robotoad]
* edgar-rft
suggests writing SmallTalk programs with ed
<aeth>
"Note the consistent user interface and error reportage. Ed is generous enough to flag errors, yet prudent enough not to overwhelm the novice with verbosity."