graphene has quit [Remote host closed the connection]
<stacksmith>
G'morn... Has anyone experinced SBCL all of a sudden no longer saving lambda-lists - but only for some code? And recompiling does not help...
graphene has joined #lisp
parjanya has joined #lisp
mange has quit [Remote host closed the connection]
fikka has joined #lisp
Kundry_Wag_ has quit [Quit: Leaving...]
daniel-s has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 245 seconds]
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
marusich has joined #lisp
fikka has joined #lisp
marusich has quit [Client Quit]
eli_oat1 has quit [Quit: Leaving.]
dddddd has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
eli_oat1 has joined #lisp
jfranci__ has joined #lisp
Jesin has quit [Ping timeout: 260 seconds]
lemonpepper24 has joined #lisp
Jesin has joined #lisp
fikka has joined #lisp
orivej has joined #lisp
Jesin has quit [Remote host closed the connection]
jfranci__ has quit [Ping timeout: 276 seconds]
MinnowTaur has quit [Remote host closed the connection]
lansiir has quit [Read error: Connection reset by peer]
jfrancis_ has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
jfrancis_ has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
MoziM has joined #lisp
jack_rabbit has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
jack_rabbit has quit [Client Quit]
brettgilio has quit [Read error: Connection reset by peer]
<skidd0>
so coming from Flask and Python, I've used SQLAlchemy as an ORM for a database. With CL, does an ORM provide as much of a benefit to the programmer?
lemonpepper24 has quit [Remote host closed the connection]
<skidd0>
by that i mean, ORMs help make querying through database logic faster/easier to write (compared to SQL queries).
<skidd0>
looking at Cliki I see a lot of options for SQL and not so many for ORMs
les has quit [Quit: ""]
les has joined #lisp
karlosz has joined #lisp
Arcaelyx has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
rumbler31 has quit [Remote host closed the connection]
brettgilio has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 265 seconds]
<sabrac>
skidd0: I cannot offer ORM recommendations pro or con as I use straight SQL (or s-sql) but you might look at mito and see if it works for you.
Guest35797 has joined #lisp
fikka has joined #lisp
karlosz has quit [Quit: karlosz]
anewuser has quit [Quit: anewuser]
subroot has quit [Quit: Leaving]
elfmacs has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 244 seconds]
panji has joined #lisp
fikka has joined #lisp
brettgilio has joined #lisp
<sabrac>
skidd0: It really depends on what you want an ORM to do for you and the complexity of your data relationships and how well you understand them. I write functions with embedded s-sql calls that probably do the same thing you would do with an ORM.
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
Bike has quit [Quit: Lost terminal]
fikka has quit [Ping timeout: 276 seconds]
igemnace has joined #lisp
nowhere_man has joined #lisp
brettgilio has quit [Remote host closed the connection]
k4rtik has joined #lisp
fikka has joined #lisp
<skidd0>
thanks you, aeth and sabrac
<skidd0>
i'll look into s-sql
<skidd0>
and my intuition was the, due to lisp's "power", ORMs are less of an improvement compared to other offerings
skidd0 has quit [Quit: WeeChat 2.1]
Guest35797 has quit [Ping timeout: 255 seconds]
<sabrac>
skidd0: obligatory disclaimer - I am the maintainer for Postmodern (and thus s-sql). It is again under active development so if there is something you want, set up an issue on the github https://github.com/marijnh/Postmodern
fikka has quit [Ping timeout: 240 seconds]
Jesin has joined #lisp
<shka1>
sabrac: awesome!
gector has quit [Ping timeout: 244 seconds]
Jesin has quit [Max SendQ exceeded]
Folkol has joined #lisp
Jesin has joined #lisp
<panji>
hello
fikka has joined #lisp
Jesin has quit [Max SendQ exceeded]
Jesin has joined #lisp
k4rtik has quit [Quit: WeeChat 2.2]
<sabrac>
Hello panji
<panji>
hello sabrac
<panji>
I finally satisfied with project i made for learning common lisp (https://github.com/epanji/decision-tree). if anyone here willing to give advice or criticize it, please do. but, please don't be so harsh to make me break down. :-)
Jesin has quit [Max SendQ exceeded]
Jesin has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
Jesin has quit [Max SendQ exceeded]
Jesin has joined #lisp
vlatkoB has joined #lisp
Jesin has quit [Max SendQ exceeded]
Jesin has joined #lisp
ninegrid has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Jesin has quit [Max SendQ exceeded]
<sabrac>
panji: I do not have time to review the code tonight, but I certainly want to congratulate you for documenting, testing and even a youtube video demo!
Jesin has joined #lisp
<panji>
sabrac: ah, right.. i forgot to consider timezone. thanks for the response.
Jesin has quit [Max SendQ exceeded]
Jesin has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
Jesin has quit [Max SendQ exceeded]
Jesin has joined #lisp
<shka1>
panji: i would be delighted if you could just implement C4.0 algorithm
<panji>
shka1: i don't know anything about C4.0 algorithm, maybe i will look at it later.
Jesin has quit [Max SendQ exceeded]
<shka1>
panji: C4.0 is essentially brown boosted variant of C3.5
<shka1>
there is implementation in C
<panji>
shka1: let me take notes on that as reading material, thanks.
nowhere_man has quit [Remote host closed the connection]
fikka has joined #lisp
jerme__ has quit [Ping timeout: 276 seconds]
banjiewen has quit [Ping timeout: 276 seconds]
d4gg4d__ has joined #lisp
alms_clozure_ has joined #lisp
banjiewen has joined #lisp
alms_clozure has quit [Ping timeout: 276 seconds]
alms_clozure_ is now known as alms_clozure
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Kevslinger_ has joined #lisp
mjl_ has joined #lisp
billstclair_ has joined #lisp
jerme__ has joined #lisp
dkrm has quit [Ping timeout: 276 seconds]
jasom has quit [Ping timeout: 276 seconds]
billstclair has quit [Ping timeout: 276 seconds]
mjl has quit [Ping timeout: 276 seconds]
rvirding has quit [Ping timeout: 276 seconds]
adulteratedjedi has quit [Ping timeout: 276 seconds]
lieven has quit [Ping timeout: 276 seconds]
billstclair_ is now known as billstclair
mjl_ is now known as mjl
devlaf_ has joined #lisp
rvirding has joined #lisp
drduck` has joined #lisp
adulteratedjedi has joined #lisp
drduck has quit [Ping timeout: 276 seconds]
beach has quit [Ping timeout: 276 seconds]
itruslove has quit [Ping timeout: 276 seconds]
Kevslinger has quit [Ping timeout: 276 seconds]
voidlily has quit [Ping timeout: 276 seconds]
thekolb has quit [Ping timeout: 276 seconds]
devlaf has quit [Ping timeout: 276 seconds]
d4gg4d_ has quit [Ping timeout: 276 seconds]
PyroLagus has quit [Ping timeout: 276 seconds]
d4gg4d__ is now known as d4gg4d_
nowhere_man has joined #lisp
devlaf_ is now known as devlaf
dkrm has joined #lisp
krrrcks has quit [Ping timeout: 260 seconds]
billstclair is now known as Guest84935
vibs29 has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 255 seconds]
krrrcks has joined #lisp
mrottenkolber has joined #lisp
vibs29 has joined #lisp
PyroLagus has joined #lisp
mrottenkolber is now known as Guest34386
fikka has joined #lisp
ofi has joined #lisp
Inline has quit [Quit: Leaving]
ninegrid has joined #lisp
lieven has joined #lisp
lieven has quit [Changing host]
lieven has joined #lisp
jasom has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
voidlily has joined #lisp
ismdeep has joined #lisp
ismdeep has quit [Client Quit]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
red-dot has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
fikka has joined #lisp
itruslove has joined #lisp
jfrancis_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
jfrancis_ has quit [Remote host closed the connection]
elfmacs has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
flamebeard has joined #lisp
fikka has joined #lisp
rumbler31 has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 240 seconds]
moei has joined #lisp
fikka has joined #lisp
beach has joined #lisp
<beach>
Good morning everyone!
<LdBeth>
beach: hello
scymtym has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
robotoad has quit [Quit: robotoad]
Smokitch has joined #lisp
shka1 has quit [Ping timeout: 256 seconds]
fikka has quit [Quit: leaving]
fikka has joined #lisp
carmack has quit [Ping timeout: 268 seconds]
xificurC has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
parjanya has quit [Read error: Connection reset by peer]
heisig has joined #lisp
fikka has joined #lisp
panji has quit [Ping timeout: 276 seconds]
scymtym has joined #lisp
xaotuk has joined #lisp
milanj__ has quit [Quit: This computer has gone to sleep]
APic has quit [Ping timeout: 240 seconds]
parjanya has joined #lisp
parjanya has quit [Remote host closed the connection]
jfrancis_ has joined #lisp
<shka>
good morning
<beach>
Hello shka.
jfrancis_ has quit [Ping timeout: 240 seconds]
Guest84935 is now known as billstclair
billstclair has quit [Changing host]
billstclair has joined #lisp
billstclair has joined #lisp
xaotuk has quit [Ping timeout: 240 seconds]
hhdave has joined #lisp
azrazalea has quit [Ping timeout: 268 seconds]
<blep-on-external>
hi shka
froggey has quit [Ping timeout: 240 seconds]
<shka>
blep-on-external: hello
<shka>
blep-on-external: hello
<shka>
beach: hello
<theemacsshibe[m]>
hello
<shka>
i was wondering
<shka>
is it possible to open mcclim application on remote machine, but display window on local machine?
rumbler31 has joined #lisp
<theemacsshibe[m]>
you could use X forwarding given X is the only backend
<shka>
i would prefer to avoid it if possible
<theemacsshibe[m]>
if you ssh in, do `ssh -Y` then your usual arguments to make ssh forward X over and set DISPLAY appropriately
MoziM has quit [Quit: WeeChat 2.2]
rumbler31 has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
makomo has joined #lisp
orivej has joined #lisp
vtomole has joined #lisp
_cosmonaut_ has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
azrazalea has joined #lisp
rozenglass has quit [Remote host closed the connection]
reverse_1ight has quit [Ping timeout: 248 seconds]
Folkol has joined #lisp
pjb has joined #lisp
angavrilov has joined #lisp
phoe_ has joined #lisp
<phoe_>
Hey! I have a style question.
<_death>
the answer is "black"
<phoe_>
I am making instances of some class via MAKE-INSTANCE. These instances are named, in a way similar to class metaobjects - each instance has a name, and they are referred to by their names.
<phoe_>
At the moment, I have an INITIALIZE-INSTANCE :AFTER method that automatically registers each instance after it's created, but it doesn't seem right to me.
<phoe_>
For example, this doesn't allow me to make anonymous instances, and seems inconsistent with how I can do (MAKE-INSTANCE 'CLASS) that doesn't seem to have any side effects.
<phoe_>
Should I instead write it so MAKE-INSTANCE only returns the instance, and the task of "registering" that instance is delegated to some macro?
<pjb>
phoe_: it is perfectly right for a class to keep track of its instances. This can be done with this :after method.\
<phoe_>
So, instead of (make-instance 'foo ...), should this be (define-foo ...)?
<pjb>
phoe_: the question for you, is whether you may need to have several trackings, if you need different sets of those instances.
milanj__ has joined #lisp
schweers has joined #lisp
<pjb>
If you just want all the instances of that class (and subclasses), then tracking them from initialize-instance :after is ok.
<phoe_>
pjb: I don't think so, the way I think of it is, a symbol is going to name one and only one instance ever.
<pjb>
or initialize-instance, rather, because I would reserve :after and :before to the client of a class or library, but it's just an API choice.
fikka has joined #lisp
<pjb>
phoe_: think namespaces.
<phoe_>
pjb: yes, exactly. I want a new namespace for my instances.
<pjb>
The same person can also be known under different names in different countries.
<phoe_>
Except (MAKE-INSTANCE 'CLASS) doesn't (seem to) bind the new instance anywhere.
<pjb>
In this case, you will want a different register method.
<pjb>
(let ((i (make-instance 'class))) (register i :name 'foo :namespace 'china) (register i :name 'jean-pierre :namespace 'france))
<pjb>
And define-named-class-instance can expand to (register (make-instance 'class) :name name :namespace 'global)
<pjb>
or &optional namespace
<pjb>
Do you want also to have bindings? I would use a define macro only if it created a (variable or symbol-macro) binding.
<pjb>
Once I parsed a mail.log, and bound all the data about a given message to variables named after the message-id (in a specific package).
<_death>
I think a macro is ok here.. it could expand to (setf (find-foo ...) ...) or ensure-foo that does it
<phoe_>
Yep. I think ENSURE-FOO is what I want here.
fikka has quit [Ping timeout: 245 seconds]
<phoe_>
_death: thanks.Iit's yet another time you help me with MOPlike constructs. (:
jmercouris has joined #lisp
<jmercouris>
so in reading Gentle introduction to symbolic computation I came across this: "FUNCTION returns the functional interpretation of its unevaluated argument"
<_death>
pjb went more meta by naming namespaces ;)
<jmercouris>
what does that mean?
nullniverse has quit [Ping timeout: 276 seconds]
eminhi has joined #lisp
<phoe_>
jmercouris: basically, (FUNCTION ...) does not evaluate ...
<phoe_>
Instead, it interprets the ... literally
<jmercouris>
why can't we then use '?
<pjb>
it means that you cannot write (function (intern "FOO")) but you have to write (function foo).
<phoe_>
and returns a function object
<shka>
jmercouris: try (function sort)
<pjb>
FUNCTION is a special operator that doesn't evaluate its argument, just like QUOTE.
<jmercouris>
shka: returns as expected
<jmercouris>
but what is the difference between QUOTE and FUNCTION
<shka>
notice that sort is not evaluated
<jmercouris>
why do we have both?
<pjb>
but when QUOTE returns the argument as-is, FUNCTION returns the actual function object that is named by the argumnet.
<shka>
different things
<jmercouris>
pjb: Aha
housel has quit [Remote host closed the connection]
<jmercouris>
I see now
<jmercouris>
so FUNCTION is like getting the value of the function stored at that symbol?
<shka>
the only thing in common, really is that they are both special, and both won't evaluate it's argumetns
housel has joined #lisp
<shka>
jmercouris: exactly
<shka>
just like #'sort
<shka>
you can (function sort)
fikka has joined #lisp
<pjb>
jmercouris: now, the difference is when you have local functions (ie. closures). (funcall (quote foo)) will always call the global function named foo, stored in (symbol-function 'foo). On the other hand, (funcall (function foo)) will call the local function foo, when there is one.
<jmercouris>
okay, the second part I don't understand
<jmercouris>
but the first part of what you said, interesting
<_death>
there is also the case of (function (lambda ...)) which returns a functional object for the lambda expression
<pjb>
jmercouris: so outside of a lexical scope where you have local functions, using 'foo or #'foo is mostly semantically equivalent.
<pjb>
jmercouris: analyze the code.
<pjb>
(function foo) makes reference to the flet foo. (quote foo) makes reference to the defun foo.
<beach>
jmercouris: Careful. The function is not necessarily stored in the symbol.
<jmercouris>
I don't know FLET yet, nor do I know GLOBAL
<jmercouris>
beach: I remember the conversation we had, which is why I was wondering about this as well
<shka>
remember that things like (setf car) also are functions
<shka>
#'(setf car)
<jmercouris>
the author again goes on to say, "If the argument is a symbol, it generally returns the contents of the symbol's funciton cell."
<jmercouris>
which I now know is invalid
<pjb>
jmercouris: read again, global is just a symbol. The returned result after "-->" is data.
<beach>
jmercouris: (function bla) returns the function with the name bla. There does not have to be any function cell.
<_death>
jmercouris: right.. if you want the full details, check the clhs
fikka has quit [Ping timeout: 240 seconds]
<pjb>
jmercouris: notaly, as a special operator function creates closure objects: (let ((y 42)) (function (lambda (x) (+ x y)))) #| --> #<ccl:compiled-lexical-closure #x302002617AEF> |#
<pjb>
+b
<jmercouris>
pjb: Yeah, I understand that as well, it makes sense to me
<jmercouris>
_death: yes
<jmercouris>
beach: Indeed!
random-nick has joined #lisp
<jmercouris>
Has anyone tried to get in touch with the author? do they accept corrections?
<pjb>
jmercouris: I would assume the author(s) of gentle are retired now.
<jmercouris>
the PDF is freely available on the CMU website I believe, I wonder if it would be legal to publish a set of revisions based on the book
<jackdaniel>
afaik he responds to emails; someone asked me how to fix clx for some Gentle example and he has asked the author if he can modify his code before that (with positive answer)
<pjb>
Is he not on a tropical island, drinking margharitas?
<jmercouris>
pjb: He isn't that old
<jackdaniel>
nobody is too old to dring margharitas on a tropical island!
<phoe_>
^
<_death>
I think it's a pedagogical style where simplicity is more valued than correctness.. where they don't want to "bog you down with the details".. this may work for some people, especially if they don't rely on it as the only source of information.. the CLHS is the authoritative source nowadays (with small exceptions agreed upon by community and implementations)
<jmercouris>
since ASDF is not part of the spec (I believe), why was it integrated into most popular implementations?
<_death>
and it may be that the misconception will be corrected later on in the book.. if you're bothered by such things, gentle may not be the right book for you.. I think PCL tries to be more strict in that regard
<shka>
or go for CLtL
<_death>
jmercouris: because it solved a real problem and had many users.. then it evolved into a little monster :)
<shka>
'little'
<jackdaniel>
and implementations are afraid to touch it from where it settled ;-)
<shka>
omission of defsystem from standard was a mistake
<jmercouris>
_death: I like this book, even if it would be potentially simplifying things for me, it is a nice cover to cover read
<LdBeth>
First, ASDF is one implementation of conventional DEFSYSTEM
<shka>
asdf corrects that mistake
<jackdaniel>
so you say, that make should be part of (say) C++? ,p
markoong has joined #lisp
<jmercouris>
_death: I'm on page 226, and I still manage to read every day, since it isn't so heavy
<LdBeth>
Second, it’s designed for mainstream POSIX systems
<jmercouris>
jackdaniel: the difference here is that MAKE is a separate program, not part of the C++ compiler
<_death>
jmercouris: that's good.. so like I said, just treat it as one of several sources of information
<beach>
jmercouris: What? ASDF is a separate program as well.
<jmercouris>
Interesting, that I did not know
<LdBeth>
jackdaniel: although make is part of POSIX standard
<jmercouris>
beach: I assumed it was some extension added to SBCL, CCL, ETC, I didn't realize that it was a separate program that just ships with them when you install them
<jackdaniel>
LdBeth: I'm confused now, so I'll cease to read to avoid further confusion towards my day :-)
<jackdaniel>
s/towards/through/
<beach>
jmercouris: You are not considering something a separate program if and only if it is in a separate Unix executable file do you?
<jmercouris>
s/through/throughout
<jmercouris>
beach: that is what I consider a separate program, otherwise I consider them part of the same system, and just different functionalities
<beach>
jmercouris: That would be silly because then all of the tools of Genera would be one single program.
<_death>
jmercouris: here is a program: (defun hello () 'hi)
<jmercouris>
is the save routine within a text editor a different program than the routine that handles inputting a keystroke?
<phoe_>
jmercouris: d'oh, ASDF is a separate program
<jmercouris>
can a single loaded lisp image said to contain many programs at once?
<beach>
Of course.
<LdBeth>
Of course
<jmercouris>
but they all have same PID no?
<phoe_>
it's just that implementations decided to bundle it with themselves
<_death>
jmercouris: yes, you can consider it a different program with inputs and outputs implicitly specified
<beach>
jmercouris: You have been brainwashed by Unix.
<phoe_>
jmercouris: define "PID"
<TMA>
jmercouris: think of busybox for a moment -- busybox is a shell that can serve as a ls, cat, ... as well
<jmercouris>
PID = PROCESS ID
<phoe_>
jmercouris: define "process"
<jmercouris>
PROCESS = SEPARATE KERNEL LEVEL THREAD
<phoe_>
why are you using Unix terms for Lisp terms?
<LdBeth>
Then wt is a kernel:)
<phoe_>
Lisp has no notion of a PID or a process
<jmercouris>
I'll think about it, you all make an interesting point
<jackdaniel>
actually, what we call native threads now was called multiprocessing in the past
<phoe_>
so it's not an issue of whether a Lisp image contains multiple processes
<phoe_>
it's an issue of you using a wrong nomenclature
<_death>
program n. Trad. Common Lisp code. <- I like this :)
<jackdaniel>
nomnomnom-enclature
<TMA>
jmercouris: do you see the trap you have cornered yourself into? even you are making a distinction between a process and a program -- so a program does not necessarilly correspond to process in 1:1 manner
<phoe_>
(defun my-program (a b) (+ a b))
<shka>
you can fork sbcl if you want to
<shka>
not with slime, but still
<phoe_>
(incf *program-count*)
<jmercouris>
I usually always think of programs as standalone executables, whether I can fork and run another program is not the point
<shka>
soooo
<phoe_>
jmercouris: what's a "standalone executable" in Lisp?
<jmercouris>
phoe_: That's a good question
<phoe_>
jmercouris: an answer to that question is an answer to your issue with program nomenclature
<pjb>
jmercouris: for example, on a unix box, when you run a "program" you are generally running several processes!
<pjb>
jmercouris: including several executable.
Kundry_Wag has joined #lisp
<pjb>
jmercouris: programs may be compound objects, and if you have a X11 GUI, then your program runs in the X11 server, will often have a X11 client GUI, and other back-end programs. As a user you would only see windows on the screen, but this just hides the complexity of such compound programs.
<pjb>
jmercouris: and on the other hand, when you run programs on iOS, where fork is disabled for user applications, you could have a single program running in a single process that is composed of several normal unix programs (eg, gzip, git, gcc, emacs, etc, all embedded into a single program and a single process).
<jmercouris>
well then, what exactly is a program?
<pjb>
jmercouris: So, I would say, it's not bad to try to understand things from what you know, but for this you have to really know well what you know. The problem is not so much that you assume lisp would be like unix, as the fact that you don't really know unix either in the first place.
<shka>
what is love
<pjb>
jmercouris: there's no difference between a routine, a subroutine, a procedure, a function, or a program.
<jmercouris>
pjb: I'll admit, I am not a systems programmer :P
<jmercouris>
is a single line of assembly a program?
<pjb>
jmercouris: there may be different technical ways to call one from another, different instructions, but this doesn't change fundamentally what they are. Basically, just functions.
<pjb>
jmercouris: of course, it can be.
<jmercouris>
so a program, is, a function?
<pjb>
Or more.
<pjb>
This is all conventionnal.
<LdBeth>
A collection of those which performed certain tasks is a program
<pjb>
But it is quite remote to the technical aspect that everything is code or data in the computer.
<pjb>
From a user point of view, a program will be a unit of interaction and data manipulation = a user task.
<pjb>
But for the computer, it's all a blougiboulga of code.
<_death>
a program is a specification for a machine.. our machines can mimic other machines, and we write our specifications so that the machines we have will mimic the machines we want
<jmercouris>
I guess that is a most general definition
<pjb>
jmercouris: this is very powerful: this allows you to define any abstraction you want at any level, using just lisp functions!
<pjb>
jmercouris: so you can write programs (several of them) in a single lisp image. You can write whole operating system in a lisp image.
<jmercouris>
I guess you can, and they interact with each other
<pjb>
You can even include multiple machines and network them in a lisp image.
AetherWind has quit [Quit: Leaving]
<_death>
another way to think of it is that a program is a description of a process, which gives a more dynamic view
fikka has quit [Ping timeout: 256 seconds]
phoe has quit [Ping timeout: 260 seconds]
phoe has joined #lisp
<LdBeth>
pjb: how? I think a lisp image is just a mem heap representation
<pjb>
jmercouris: notice that 1- in lisp, we have some separation of addressing spaces, since if you give a function a reference to one object, it cannot manipulate this reference to access to any other object. and 2- in unix one important idea is that programs shall be small units doing one thing well, and process creation is optimized so that you can protect the execution of each of those small program and combine them easily and
<pjb>
efficiently in bigger "systems" or programs.
<_death>
LdBeth: memory is an abstraction that is made concrete by the OS and hardware, which may include multiple machines
<jmercouris>
pjb: Yes, I've noticed that, packages and all that
<pjb>
Basically, this is the same thing, implemented in two different ways. in lisp we have a controled execution model, so we can combine small programs that cannot access the data of other small program because they can't compute addresses, and we combine them easily by mere function calls. In unix we have a lower level execution model, where processes can compute addresses and crash, but they are protected by the hardware (MMU), and
<pjb>
kernel, and we combine them easily by mere forking and syscalls (IPC such as pipes).
<pjb>
But it's the same thing.
<pjb>
LdBeth: consider also the memory from the point of view of the unix kernel. It's like a lisp image.
<pjb>
bbl
fikka has joined #lisp
m00natic has joined #lisp
phoe has quit [Ping timeout: 244 seconds]
phoe has joined #lisp
pjb has quit [Ping timeout: 244 seconds]
karswell has quit [Remote host closed the connection]
karswell has joined #lisp
jasmith has quit [Remote host closed the connection]
jasmith has joined #lisp
igemnace has quit [Ping timeout: 255 seconds]
jasmith has quit [Remote host closed the connection]
jasmith has joined #lisp
pagnol has joined #lisp
jasmith has quit [Excess Flood]
jasmith has joined #lisp
phenoble has joined #lisp
jasmith has quit [Ping timeout: 265 seconds]
jasmith has joined #lisp
jasmith has quit [Excess Flood]
phenoble has quit [Client Quit]
MoziM has joined #lisp
phenoble has joined #lisp
rozenglass has joined #lisp
beach has quit [Ping timeout: 256 seconds]
beach has joined #lisp
xaotuk has joined #lisp
phoe has quit [Ping timeout: 245 seconds]
phoe has joined #lisp
X-Scale has quit [Ping timeout: 260 seconds]
<jmercouris>
so I have a lisp web application communicating with AJAX to some JS I wrote
<jmercouris>
I want to represent different types of lisp objects using JS on the web page
jfrancis_ has joined #lisp
jfrancis_ has quit [Remote host closed the connection]
<jmercouris>
an example of some simple types of objects include a list, a table
<jmercouris>
I am trying to think of how to encode the object type within the JSON
fikka has quit [Ping timeout: 240 seconds]
<jmercouris>
the only thing that comes to mind is having another slot in my objects that corresponds to the type of object, but that seems dumb
<random-nick>
do you mean "type" in the sense of deftype or in the sense of defclass?
<jmercouris>
in the sense of defclass
<jmercouris>
so currently I have: (encode-json (make-instance 'event :key-code "code")) -> "{\"keyCode\":\"code\"}"
<jmercouris>
I am proposing "{\"keyCode\":\"code\", \"class\:\"event\"}"
orivej has joined #lisp
<jmercouris>
any downsides with this approach? any better ideas?
<jmercouris>
well, sounds like everyone is unanimous agreement that there can be no better engineered solution :D
fikka has joined #lisp
<tfb>
jmercouris: I think you could have type objects (not just names of them) but you need to ship them across as names I think
eminhi has quit [Remote host closed the connection]
pjb has joined #lisp
<random-nick>
jmercouris: why not make a generic function for serialising an object to json?
<random-nick>
since you're sending it to JS code which wouldn't understand the classes anyway
<jmercouris>
random-nick: I am using encode-json which is part of datafly
<jmercouris>
random-nick: because the JS code must use the classes to determine HOW to render the data
<jmercouris>
a list and a table will not be rendered the same way in HTML
skeuomorf has joined #lisp
<random-nick>
why not determine that in lisp code and only send to JS code exactly how you want it rendered
<jmercouris>
you mean sending HTML?
<pjb>
:-)
skeuomorf has left #lisp [#lisp]
<tfb>
jmercouris: that was what I meant by the type object: the JS objects would have a type object slot, and the type object contains the information JS needs to render them. But I think those objects need to exist only on the JS side and have names, and it's the names that get shipped from the Lisp side. (So I'm agreeing with your approach I think!)
<jmercouris>
tfb: Sounds we are on the same page then :)
<jmercouris>
Sorry about my english, I'm not sure what is going on
<jmercouris>
I keep omitting words for some reason
BitPuffin has joined #lisp
<random-nick>
jmercouris: well, I'm thinking more like having classes on the JS side whose JSON representations you send from lisp code
xaotuk has quit [Ping timeout: 264 seconds]
<random-nick>
that way the JS code doesn't have to know about classes in lisp code
<jmercouris>
random-nick: Yeah, it is the same idea, just a difference of where the class definitions are stored
froggey has joined #lisp
<jmercouris>
in any case, if you give some JSON to the JS that doesn't have a class available, it will not render
<jmercouris>
In other words, no suitable class for rendering some JSON found within the JS
<jmercouris>
so, regardless, you'llh ave to maintain some parity between the JS and LISP
graphene has quit [Remote host closed the connection]
<jmercouris>
luckily I control both sides of the system, so it should be fine in any casey
<jmercouris>
s/casey/case
Folkol has joined #lisp
graphene has joined #lisp
devlaf has quit [Changing host]
devlaf has joined #lisp
devlaf has joined #lisp
pjb has quit [Read error: Connection reset by peer]
azimut has quit [Ping timeout: 245 seconds]
azimut has joined #lisp
APic has joined #lisp
igemnace has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
housel has quit [Read error: Connection reset by peer]
jmercouris has quit [Remote host closed the connection]
milanj has joined #lisp
acolarh has quit [Ping timeout: 245 seconds]
faraco has joined #lisp
faraco has joined #lisp
faraco has quit [Changing host]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
fikka has joined #lisp
rumbler31 has joined #lisp
red-dot has joined #lisp
rumbler31 has quit [Ping timeout: 245 seconds]
beach has quit [Ping timeout: 245 seconds]
beach has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<jmercouris>
It works if I run macroexpand-1, I get the expected output
<jmercouris>
but when loading my system, I get an error
milanj has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<phoe_>
jmercouris: you have tried to use the macro before it was defined
<_death>
your expectation is wrong..
<phoe_>
or so it seems
<jmercouris>
phoe_: The macro is loaded beforehand for sure
<jmercouris>
it is in a separate file
<jmercouris>
the expectation is indeed maybe wrong, let me validate that
<_death>
you likely want to quote the symbol in the get-named-command form..
<jmercouris>
ah, get-named-command expects a string, not a symbol
<jmercouris>
that lead me onto the write track, thank you _death
<jmercouris>
s/write/right
<phoe_>
oh right
<phoe_>
line 11, s/,name/',name/
saki has joined #lisp
<jmercouris>
would it be possible to make the SBCL traces any more mysterious?
<phoe_>
jmercouris: huh?
<jmercouris>
I'm just saying, any time a signal is raised due to some error, I have no idea what all the things in SBCL mean
<_death>
there's no need to read the backtrace in this case.. it's enough to read the error text: The variable ATHENA::DEFINE is unbound.
<jmercouris>
the Backtrace is really hard to read for me
<jmercouris>
_death: I've fixed the error in this case, I'm just thinking in general
<jmercouris>
just complaining for the sake of it I guess, ignore it
makomo has quit [Quit: WeeChat 2.0.1]
jfrancis_ has joined #lisp
jasmith has joined #lisp
<flip214>
jmercouris: don't worry, reading backtraces is one of the harder things in CS - in any language.
pjb has joined #lisp
pjb is now known as Guest29226
<flip214>
you need to know enough about all the things in use to determine which frame might be the real cause, and which ones are just noise.
<jmercouris>
flip214: Yeah, I would agree with that, I can't say I've ever been so truly enlightened in any language as to grasp immediately a backtrace
jfrancis_ has quit [Ping timeout: 276 seconds]
Murii is now known as Murii__
Kundry_Wag has joined #lisp
jasmith has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
SaganMan has joined #lisp
xaotuk has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
rumbler31 has quit [Ping timeout: 268 seconds]
Achylles has joined #lisp
Kundry_Wag has joined #lisp
Bike has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<eminhi>
flexi-streams : with-output-to-sequence may help
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<tfb>
I'm the wrong person to answer this but traditionally streams either deal with (a subtype of) character, or (a subtype of) integer. And CL-the-standard is missing some stuff around this I think
<tfb>
(ie with-output-to-sequence as eminhi says)
<jmercouris>
let me give it a try I guess
kuribas has quit [Remote host closed the connection]
<jmercouris>
I'll be surprised if it renders properly, but you never know
jasmith has joined #lisp
<jmercouris>
wow, unbelievable
fikka has joined #lisp
<jmercouris>
it actually worked, thank you!
<jmercouris>
I hope to begin understanding streams after I finish with gentle introduction
<jmercouris>
to symbolic compuation
<tfb>
Somewhere there is stuff (also not in the standard) about bivalant sreams which are streams which can contain both characters and bytes, and which I think you really kind of need for webby stuff
<eminhi>
tfb: we can use *open* with different :element-type, when finer control over stream is needed
<tfb>
(and. doh, flexi-streams is 'Flexible bivalent streams for Common Lisp': I should have looked at it!)
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
vlad_ is now known as DonVlad
pagnol has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
optikalmouse has quit [Quit: optikalmouse]
fikka has quit [Ping timeout: 240 seconds]
pjb has joined #lisp
<pjb>
/whoami
<jmercouris>
you are PJB
<pjb>
Thanks.
<pjb>
I had a doubt.
fikka has joined #lisp
jmercouris has quit [Remote host closed the connection]
<fe[nl]ix>
pjb: you are number two
trittweiler has quit [Ping timeout: 240 seconds]
rpg has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
ebrasca has quit [Remote host closed the connection]
red-dot has joined #lisp
ebrasca has joined #lisp
saki has joined #lisp
chiyosaki has quit [Ping timeout: 255 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
skidd0 has joined #lisp
hhdave has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
brendyn has quit [Ping timeout: 244 seconds]
emma has joined #lisp
emma has joined #lisp
emma has quit [Changing host]
elfmacs has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 244 seconds]
MoziM has quit [Quit: WeeChat 2.2]
karlosz has quit [Quit: karlosz]
orivej has quit [Ping timeout: 276 seconds]
terpri has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
fikka has joined #lisp
karlosz has quit [Quit: karlosz]
elfmacs has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
jack_rabbit has quit [Quit: Leaving]
shka1 has joined #lisp
karlosz has joined #lisp
terpri has joined #lisp
fikka has joined #lisp
sauvin has quit [Remote host closed the connection]
Kaisyu has quit [Quit: Connection closed for inactivity]
xaotuk has quit [Remote host closed the connection]
xaotuk has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
karlosz has quit [Quit: karlosz]
fikka has quit [Ping timeout: 244 seconds]
xaotuk has quit [Quit: xaotuk]
slyrus1 has joined #lisp
elfmacs has quit [Ping timeout: 276 seconds]
milanj has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
angavrilov has quit [Read error: Connection reset by peer]
FreeBirdLjj has quit [Remote host closed the connection]
fikka has joined #lisp
elfmacs has joined #lisp
karlosz has joined #lisp
schweers has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 245 seconds]
elfmacs has quit [Ping timeout: 276 seconds]
orivej has joined #lisp
parjanya has joined #lisp
fikka has joined #lisp
FreeBirdLjj has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
<jasom>
skidd0: If nobody mentioned it, EXIT should not be in the CL package, so if you don't use CL-USER there should be no conflict...
<skidd0>
oh!
karlosz has quit [Quit: karlosz]
<skidd0>
that's handy
<jasom>
cl-user is an implementation-defined superset of the CL package; it has non-portable but useful things (most implementations define QUIT for example; SBCL defined EXIT in addition to QUIT because they changed the interface IIRC)
pierpal has quit [Remote host closed the connection]
fikka has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rpg has joined #lisp
kuwze has quit [Ping timeout: 252 seconds]
<skidd0>
sabrac: with s-sql and postmodern, how tedious is session handling?
<skidd0>
i found with-connection
fikka has quit [Ping timeout: 276 seconds]
random-nick has quit [Read error: Connection reset by peer]
<skidd0>
the general user story is "I want to add a task." > "I execute 'to-do-binary --add-task'"
asarch has joined #lisp
<skidd0>
which, in code would then open a connection (since the binary doesn't live in memory and thus can't maintain an open connection)
<skidd0>
and add the task to the db
<skidd0>
so in my understanding, every db op (like add-task) would need to be wrapped in the with-connection
<skidd0>
sabrac: are you the author of sabra on the hill?
asarch has quit [Remote host closed the connection]
jfranci__ has joined #lisp
jfrancis_ has quit [Ping timeout: 276 seconds]
azimut has quit [Ping timeout: 245 seconds]
milanj has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
makomo has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
azimut has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
fikka has joined #lisp
graphene has joined #lisp
random-nick has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
karlosz has quit [Quit: karlosz]
terpri has quit [Ping timeout: 276 seconds]
brettgilio has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
karlosz has joined #lisp
Kundry_W_ has joined #lisp
m00natic` has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 248 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
graphene has quit [Remote host closed the connection]
cage_ has quit [Quit: Leaving]
graphene has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
FreeBirdLjj has joined #lisp
rpg has joined #lisp
rpg has quit [Client Quit]
karlosz has quit [Quit: karlosz]
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
nickenchuggets has joined #lisp
kerrhau has joined #lisp
kerrhau has joined #lisp
kerrhau has quit [Changing host]
parjanya has quit [Read error: Connection reset by peer]
fikka has joined #lisp
rpg has joined #lisp
karlosz has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
fikka has joined #lisp
chiyosaki has joined #lisp
saki has quit [Ping timeout: 276 seconds]
kyby64 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
brettgilio has quit [Read error: Connection reset by peer]
<jasom>
skidd0: that is correct. I would recommend doing a with-connection around your main function though (assuming *most* invocations of your program will need to connect to the database).
<skidd0>
well the "main" function that the end-user interacts with is a cli function with CLON
<skidd0>
i'm wondering how to with-connection the commands
<skidd0>
when the cli program is a separate package from the to-do package
<jasom>
skidd0: assuming the commands are functions, just put it in the body of those functions.
<skidd0>
yeah okay
<jasom>
I'm just suggesting you not do (with-connection <lookup some data>) (with-connection <modify some data>) ... or something stupid like that
fikka has joined #lisp
<skidd0>
so like (with-connection
<skidd0>
(one-thing
<skidd0>
(two-thing))
<jasom>
righ
<jasom>
right
<skidd0>
and for each command line option from clon, have a with-connection at the start of that commands function body
<skidd0>
but in that function body, i call functions from the to-do package
vlatkoB has quit [Remote host closed the connection]
<skidd0>
so i'm thinking it'd be better to wrap each of the functions in the to-do package rather than the functions in the cli
fikka has quit [Ping timeout: 268 seconds]
scymtym has joined #lisp
Jesin has joined #lisp
acolarh has quit [Ping timeout: 240 seconds]
acolarh has joined #lisp
papachan has quit [Quit: WeeChat 2.1]
fikka has joined #lisp
moei has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
FreeBirdLjj has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
shka1 has quit [Ping timeout: 260 seconds]
Fare has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
pagnol has joined #lisp
fikka has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]