kaftejiman has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
ramHero` has quit [Ping timeout: 240 seconds]
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
axion has quit [Quit: WeeChat 2.9]
IAmRasputin has joined #lisp
IAmRasputin has quit [Ping timeout: 246 seconds]
ralt has quit [Quit: Connection closed for inactivity]
Blukunfando has quit [Ping timeout: 260 seconds]
Gerula has joined #lisp
Gerula_ has quit [Ping timeout: 260 seconds]
flak has joined #lisp
rippa has quit [Ping timeout: 265 seconds]
Blukunfando has joined #lisp
davepdotorg has joined #lisp
karlosz has quit [Quit: karlosz]
renzhi has quit [Ping timeout: 260 seconds]
davepdotorg has quit [Ping timeout: 264 seconds]
jesse1010 has quit [Ping timeout: 240 seconds]
kaftejiman_ has quit [Remote host closed the connection]
kaftejiman_ has joined #lisp
IAmRasputin has joined #lisp
kaftejiman has joined #lisp
IAmRasputin has quit [Ping timeout: 246 seconds]
kaftejiman_ has quit [Ping timeout: 260 seconds]
kaftejiman has quit [Ping timeout: 260 seconds]
rippa has joined #lisp
flak has quit [Ping timeout: 240 seconds]
akoana has left #lisp ["Leaving"]
IPmonger has quit [Ping timeout: 246 seconds]
IPmonger has joined #lisp
arpunk has quit [Remote host closed the connection]
arpunk has joined #lisp
toorevitimirp has joined #lisp
defunkydrummer has quit [Ping timeout: 272 seconds]
_whitelogger has joined #lisp
rippa has quit [Read error: Connection reset by peer]
ex_nihilo has joined #lisp
frot-lab has left #lisp [#lisp]
IAmRasputin has joined #lisp
IAmRasputin has quit [Ping timeout: 265 seconds]
alxplorer has quit [Remote host closed the connection]
alxplorer has joined #lisp
Alfr_ has joined #lisp
rippa has joined #lisp
Alfr has quit [Ping timeout: 240 seconds]
alxplorer has quit [Remote host closed the connection]
frost-lab has joined #lisp
<beach>
Good morning everyone!
davepdotorg has joined #lisp
iissaacc has quit [Ping timeout: 272 seconds]
davepdotorg has quit [Ping timeout: 272 seconds]
rippa has quit [Read error: Connection reset by peer]
skapata has quit [Remote host closed the connection]
rippa has joined #lisp
rippa has quit [Read error: Connection reset by peer]
rippa has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
gravicappa has joined #lisp
defunkydrummer has joined #lisp
Bike has quit [Quit: Lost terminal]
<remexre>
is iterate's in-sequence O(n) per iteration on lists?
sts-q has joined #lisp
Patzy_ has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Looking at the macroexpansion, it could be.
zaquest has quit [Quit: Leaving]
mmohammadi981266 has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
zaquest has joined #lisp
gxt has quit [Ping timeout: 240 seconds]
gxt has joined #lisp
dbotton has quit [Quit: -a- Connection Timed Out]
dbotton has joined #lisp
sts-q has quit [Quit: ]
Patzy_ has joined #lisp
sts-q has joined #lisp
mmohammadi981266 has quit [Quit: I quit (╯°□°）╯︵ ┻━┻]
Jeanne-Kamikaze has joined #lisp
davepdotorg has joined #lisp
IAmRasputin has joined #lisp
davepdotorg has quit [Ping timeout: 260 seconds]
torbo has joined #lisp
IAmRasputin has quit [Ping timeout: 256 seconds]
torbo has quit [Remote host closed the connection]
iissaacc has joined #lisp
defunkydrummer has quit [Quit: Leaving]
torbo has joined #lisp
IPmonger has quit [Read error: Connection reset by peer]
IPmonger has joined #lisp
karlosz has joined #lisp
davepdotorg has joined #lisp
aartaka has joined #lisp
paul0 has joined #lisp
dbotton has quit [Quit: -a- Connection Timed Out]
davepdotorg has quit [Ping timeout: 272 seconds]
aartaka has quit [Read error: Connection reset by peer]
dbotton has joined #lisp
Blukunfando has quit [Ping timeout: 256 seconds]
uniminin has joined #lisp
uniminin has quit [Client Quit]
uniminin has joined #lisp
uniminin has quit [Max SendQ exceeded]
saganman has joined #lisp
Qudit314159 has joined #lisp
Bourne has quit [Ping timeout: 256 seconds]
uniminin has joined #lisp
Blukunfando has joined #lisp
Duuqnd has quit [Ping timeout: 246 seconds]
uniminin has quit [Quit: Leaving]
uniminin has joined #lisp
yoeljacobsen has joined #lisp
galex-713 has joined #lisp
yoja has joined #lisp
yoja has quit [Remote host closed the connection]
torbo has quit [Remote host closed the connection]
davepdotorg has joined #lisp
gravicappa has quit [Ping timeout: 256 seconds]
colluphid has joined #lisp
Jeanne-Kamikaze has quit [Ping timeout: 256 seconds]
davepdot_ has joined #lisp
Qudit314159 has left #lisp ["ERC (IRC client for Emacs 27.1)"]
davepdotorg has quit [Ping timeout: 260 seconds]
Lycurgus has joined #lisp
iissaacc has quit [Ping timeout: 260 seconds]
davepdot_ has quit [Ping timeout: 256 seconds]
narimiran has joined #lisp
davepdotorg has joined #lisp
karlosz has quit [Quit: karlosz]
<saganman>
what does a defun return? the last evaluated expression?
uniminin has quit [Quit: Leaving]
<Lycurgus>
it's a special form, doesn't "return" anything
<beach>
There is not such thing as "a defun". A function returns the values of the last form in the body.
<beach>
A DEFUN form returns the name of the function being defined.
<no-defun-allowed>
A defun form returns the function name :)
davepdotorg has quit [Ping timeout: 246 seconds]
<saganman>
beach, I suspected that.
frgo has quit [Remote host closed the connection]
<beach>
Which part?
<Lycurgus>
the name
<Lycurgus>
no-defun-allowed, whence ur nick?
<saganman>
beach, the last form
aartaka has joined #lisp
<beach>
saganman: Notice that, because you said "a defun" both Lycurgus and no-defun-allowed misunderstood.
<beach>
It is very important to try to use the right terminology.
<saganman>
beach, I was writing tail recursive functions yesterday where I wrote fibonaci function using different lisp elements, cond, case, if, while. After that I wrote skip first n elements which part of execise in book, where the last form is nil list
<saganman>
ah yes beach
<saganman>
I should have said function
<saganman>
not defun
<beach>
Lycurgus: Please be careful with your answers. DEFUN is a macro and not a special operator (or special form), and I know of no special form that returns no values.
<Lycurgus>
beach, acknowledged
davepdotorg has joined #lisp
IAmRasputin has joined #lisp
<saganman>
A defun form returns the function name << haha, spot on
Cymew has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Lycurgus: I don't know where no-defun-allowed came from.
IAmRasputin has quit [Ping timeout: 240 seconds]
<Lycurgus>
no-defun-allowed, acknowledged
dbotton has quit [Remote host closed the connection]
liberliver has joined #lisp
davepdotorg has joined #lisp
frgo has joined #lisp
ThaEwat has quit [Quit: killed]
infra_red[m] has quit [Quit: killed]
even4void[m] has quit [Quit: killed]
eriix[m] has quit [Quit: killed]
tekipeps[m] has quit [Quit: killed]
no-defun-allowed has quit [Quit: killed]
goldrin1227[m] has quit [Quit: killed]
Gnuxie[m] has quit [Quit: killed]
santiagopim[m] has quit [Quit: killed]
fwoaroof[m] has quit [Quit: killed]
MrtnDk[m] has quit [Quit: killed]
Dmytro[m] has quit [Quit: killed]
cairn has quit [Quit: killed]
xzax_[m] has quit [Quit: killed]
katco has quit [Quit: killed]
hansbauer[m] has quit [Quit: killed]
sammich has quit [Quit: killed]
kelamir[m] has quit [Quit: killed]
materialfuture[m has quit [Quit: killed]
xzax_[m]1 has quit [Quit: killed]
santiagopim[m]1 has quit [Quit: killed]
pcgme[m] has quit [Quit: killed]
kinope has quit [Quit: killed]
tsrt^ has quit [Max SendQ exceeded]
tsrt^ has joined #lisp
sts-q has quit [Ping timeout: 246 seconds]
kelamir[m] has joined #lisp
<aeth>
Everything returns something except for (VALUES) or something user-defined that returns (VALUES) but most of the time (except when using MULTIPLE-VALUE-CALL or MULTIPLE-VALUE-LIST) that will just implicitly create a NIL value because most uses of multiple values implicitly turns the missing nth value into NIL when the nth value is requested (including the 1st value!).
<aeth>
flip214: Sorry, I mean #.(VALUES) which is then expressed as (defun foo () (values))
<aeth>
I guess I need to use read-eval via #. in order to evalue an expression when I'm actually talking about the result
<flip214>
"something user-defined that runs (VALUES) as last form"?
<flip214>
evaluating at read time won't help with the runtime-returnvalue
<aeth>
flip214: I'm talking about the IRC read time :-)
<aeth>
but to be more serious, #.(values) is probably just going to get you NIL because it's really hard to avoid turning (values) into NIL (and you probably just want NIL when the return value isn't important, anyway)
<aeth>
heh, actually, it doesn't get you NIL
<aeth>
(list #.(values) 1) => (1)
<aeth>
in SBCL
<aeth>
in ECL, though (list #.(values) 1) => (NIL 1)
<flip214>
well, you can always add another value telling whether the previous value was important... see GETHASH
* Lycurgus
stands corrected.
<aeth>
hmm, I wonder... Is this UB or is one of the implementations wrong?
aartaka has quit [Read error: Connection reset by peer]
cjv has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
davepdotorg has joined #lisp
motersen has joined #lisp
<TMA>
aeth: (list #.(values 1 2) 3) => (1 3) ; no values are interpreted as nil where a single value is expected. like (if (values) 1 2) => 2 ; when #. interprets two values as one, it shall do the same for zero values
<TMA>
flip214: I am in favor of (NIL 1)
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 26.3)]
cjv has joined #lisp
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
<flip214>
TMA: that means that a reader macro MUST include a value into the source, even if it's "just" a NIL.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
davepdotorg has quit [Ping timeout: 246 seconds]
liberliver has joined #lisp
aartaka_d has joined #lisp
davepdotorg has joined #lisp
aartaka has quit [Ping timeout: 264 seconds]
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
cjv has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hendursa1 has joined #lisp
jonatack has joined #lisp
<TMA>
flip214: not all reader macros MUST do that (#+ and #- don't) but #. looks to me like it MUST, indeed
<flip214>
uses (values) in an example explicitly (comment reader)
bilegeek has quit [Quit: Leaving]
rogersm has joined #lisp
shka_ has joined #lisp
treflip has joined #lisp
sts-q has joined #lisp
IAmRasputin has joined #lisp
sammich has left #lisp ["Kicked by @appservice-irc:matrix.org : Idle for 30+ days"]
<TMA>
flip214: (defun hash-dot-reader (stream char) (declare (ignore char)) (cond (*read-eval* (eval (read stream t nil t))))) ; this is a valid #. reader function in my opinion
IAmRasputin has quit [Ping timeout: 264 seconds]
<TMA>
#.foo is read as the object resulting from the evaluation of the object represented by foo.
<flip214>
TMA: but you can't ignore comments if you _always_ insert a value.
<TMA>
flip214: I am not arguing for always inserting a value in general case. comments do never insert a value, #- and #+ do not always do so
<TMA>
flip214: I am arguing that #. as specified always does
resu has quit [Ping timeout: 260 seconds]
<TMA>
in a sense "the object resulting from the evaluation of (values)" is the set of no values
<TMA>
I am arguing that (list '#.(values) 1) shall evaluate to the same as (list (eval '(values)) 1)
<TMA>
and as 'nil evaluates to the same value as nil, namely nil, so shall (list #.(values) 1)
<TMA>
I do have an error in the function I have written before. it shall look thus:
<phantomics>
clisp is not "Common Lisp," it is a dialect of Common Lisp
<phantomics>
Qicklisp
<phoe>
kreyren_: the very top of the post
<phoe>
see the image
<kreyren_>
ah
<phoe>
also CLISP is the name of the implementation - it is written in C, hence CLISP
<phantomics>
Also, defun and defmacro are not "hard-coded functions," they are macros
<phoe>
also, you mix up multiple dialects
<phantomics>
By hard-coded functions, I think you're referring to the special forms, the handful of hardcoded things that are the basis for the language
<phoe>
CLISP, ECL, SBCL are all implementations of Common Lisp; Racket, Elisp, Rlisp are all different dialects
<phantomics>
(if) and (quote) are special forms, (defun) and (defmacro) are not
<phoe>
Quicklisp is only for Common Lisp impementations
<phantomics>
Special forms are neither functions nor macros
<kreyren_>
beach, about the logo i left it with upper-case L because i think it looks better :p
<kreyren_>
beach, elaborate lacking articles?
jonatack has quit [Quit: jonatack]
<kreyren_>
attempted to fix 'The'
<kreyren_>
phoe, > maybe let's start from the top - which Lisp dialects do you want to support? < -- Ideally i want it to run as many dialects and implementations as possible
<phantomics>
version 0.32.6 requires following entry -> version 0.32.6 requires the following entry
yoja has quit [Ping timeout: 240 seconds]
<phoe>
kreyren_: forgive the blunt question, do you know basics of Common Lisp?
<phantomics>
Quicklisp is easy to install and works with ABCL, Allegro CL, Clasp, Clozure CL, CLISP, CMUCL, ECL, LispWorks, MKCL, SBCL, and Scieneer CL, on Linux, Mac OS X, and Windows.
<phoe>
since the issue confuses lots of stuff that are Lisp and CL basics in general
<phantomics>
That's from the Quicklisp site naming the Lisp implementations that Quicklisp works with
<beach>
kreyren_: "a", 'the" are articles.
<kreyren_>
phoe, > Quicklisp only works with Common Lisp, so: SBCL, CCL, ECL, Clasp, ABCL, CLISP, ACL, LW < -- added them on the list
kapil_ has joined #lisp
aartaka has joined #lisp
<kreyren_>
phoe, i am confident in basics of Common lisp, but it seems that quicklisp may allow for compatibility above common lisp dialects?
<beach>
kreyren_: There is no such thing as "Common Lisp dialects".
<no-defun-allowed>
phoe: I recall this exercise being about running code on systems with Common Lisp implementations that can run Rust code but don't have a POSIX shell. Computer history isn't really basic Common Lisp, but it would be useful right now.
<phoe>
kreyren_: I kinda wonder why you confuse CL with other Lisp dialects then
<kreyren_>
beach, sorry meant implementation
<phoe>
rustlisp isn't CL, neither is elisp or racket; quicklisp doesn't run on them
<kreyren_>
no-defun-allowed, rustlang doesn't work on some systems that common lisp does that's true, but rust has a handling of platform compatibility that allows anyone to implement it on their system in theory
<kreyren_>
phoe, cargo-make is only providing the logic to run common lisp
<kreyren_>
worst case scenario i want to make a lisp wrapper that translates the toml file in common lisp
<phoe>
oh, perfect
<phoe>
then everything that isn't CL should go out of this issue
<kreyren_>
phoe, edit: cargo-make can interpret common lisp assuming rust-lisp in a working state
<kreyren_>
i.e what's it's currently doing with duckscript
<no-defun-allowed>
r-l is nowhere near running Common Lisp code.
<kreyren_>
phoe, so i can't use quicklisp for dialects of common lisp? i.e. elisp?
<phoe>
elisp is NOT a dialect of common lisp
<no-defun-allowed>
And if porting Rust isn't out of the question, why not Lisp--oh good God.
<phoe>
elisp is a dialect of lisp
<phoe>
common lisp is a dialect of lisp
<kreyren_>
phoe, dialect of lisp then!
<phoe>
where lisp is a family of languages
<aeth>
Quicklisp depends on ASDF, which heavily uses CLOS.
<kreyren_>
where the current blocker for elisp running quicklisp seems to be: Symbol’s function definition is void: defpackage
<aeth>
Heavy CLOS code would be a nightmare to port to other Lisp dialects.
<no-defun-allowed>
You cannot run Common Lisp code on rust-lisp or Emacs.
<phoe>
no, it is not
<kreyren_>
aeth, ah i see updating
<phoe>
the blocker for elisp running quicklisp is the fact that quicklisp is written in Common Lisp, not Emacs Lisp
<phoe>
like, have ever tried compiling Rust code with G++?
<sm2n>
rust is a one-implementation language, and is very dependency intensive, porting CL would be way easier...
<no-defun-allowed>
And I still don't know what machines you target that don't have a POSIX shell, but can run some Common Lisp implementation.
<kreyren_>
sm2n, my codebase is in rustlang and i am using commonlisp for a repository management
<sm2n>
but why
<kreyren_>
sm2n, because common lisp is more functional compared to shell allowing me for a better implementation
<kreyren_>
while not preventing platform compatibility if anyone decides to use non-standard system, legacy, etc..
iissaacc has quit [Ping timeout: 264 seconds]
<sm2n>
anyway, someone posted the name of the approach sbcl uses for type-inference the other day, but I lost it, could someone give me a reference?
<kreyren_>
alike i have a single board computer that has custom kernel with lisp that is not practical to use posix shell
<no-defun-allowed>
What legacy systems do you know of that run Common Lisp and your code?
<kreyren_>
no-defun-allowed, current target is VAX which i am still researching where the ideology is to work on as many systems as possible without being limited by the technology itself
<no-defun-allowed>
That makes no sense, porting a shell is probably easier than porting Lisp.
<aeth>
Emacs Lisp is close enough to Common Lisp where you get the mistaken impression that it will run your Common Lisp code and that your Common Lisp knowledge will transfer. There are quite a few incompatibility landmines hidden there, though.
<kreyren_>
was thinking that worst case scenario i can make a hardware that can be added to the VAX
<aeth>
Scheme is pretty close to Common Lisp, but renames almost everything, which helps avoid this pitfall and makes it clearer that they're separate languages.
<aeth>
(And Racket is basically Scheme where your set-car! and set-cdr! won't work.)
<kreyren_>
aeth, noted
<kreyren_>
going to update the issue
<kreyren_>
How should i rephrase https://dpaste.com/3KVUDLNGF.txt ? So to make it understandable what is quicklisp doing on the backend to use these to redefine the functions in implementation-independant code?
<phoe>
I'd remove all of this altogether and link to the Common Lisp specification
<no-defun-allowed>
Is it even necessary to mention how to write the language if you're requesting code to kick up a Lisp process?
<phoe>
why do you want to adapt this?
<phoe>
CL is already well-defined, and if you want to write CL, then you use the CL specification
<kreyren_>
no-defun-allowed, yes as i am expecting the logic to create a temporary file with the `script` content, find the supported executables and apply the flags to allow it to run that way
<kreyren_>
which also needs to prepend the codeblock that loads quicklisp
<phoe>
I'd leave the part of describing what Common Lisp works like to someone who already knows Common Lisp - it's evident to me that you don't if this paste looks good to you but still contains the DEFINE keyword that does not exist in Common Lisp, and where you list unquote below quote, not below quasiquote
<kreyren_>
which is implementation-dependent
rtypo has joined #lisp
<phoe>
or
<phoe>
I'd avoid that part altogether
<phoe>
also, the part that loads quicklisp should be (load #p"~/quicklisp/setup.lisp") - this one is implementation-independent I think
<no-defun-allowed>
No, the code that loads Quicklisp isn't implementation dependent. Starting a Lisp process and getting it to load a file is implementation-dependent, but it's not done in Lisp.
<phoe>
all the implementation conditionals are stored inside QL logic
<kreyren_>
phoe, true i don't know how common lisp works on the backend was taking that from rlisp readme
<jmercouris>
thanks for the link Bike
<phoe>
kreyren_: that's why I'd suggest skipping this part altogether
<aeth>
kreyren_: the readme of that language says that it was inspired by both CL and Scheme
<kreyren_>
phoe, checking.. note that it also can't output anything else but the logic provided
<no-defun-allowed>
Furthermore, the "hard-coded logic" you provided doesn't describe how the loading code works at all. None of it is used in your prelude code.
<phoe>
let CL work the way it works; if I understood you correctly, you are trying to provide an adapter in Rust code that allows one to run some Common Lisp implementation and load Quicklisp in it and then do something
<aeth>
kreyren_: Lisp has "dialects" (including CL, Emacs Lisp, and Scheme). Scheme itself sort of has "dialects" (including Racket). Common Lisp is a unified language that follows one specification and only has "implementations".
<kreyren_>
phoe, the `(load #p"~/quicklisp/setup.lisp")` seems to work on ECL, CLISP and SBCL on my end
<aeth>
The distinction being that writing portable Common Lisp is possible, writing portable Scheme is hard, and writing portable "Lisp" in the general sense is very, very hard.
<kreyren_>
jackdaniel, anything relevant appreciated i want to use it to implement quicklisp runner in cargo-make and possibly rlisp
<kreyren_>
so that cargo-make would be able to interpret common lisp code
<jackdaniel>
I don't know what is cargo-make, even less what is rlisp
<aeth>
kreyren_: Most Lisps don't follow any specification, are very minimalist (even more so than Scheme, which has some hard features like call/cc), and usually wind up with the label "toy Lisp". rlisp appears to be one of these.
<no-defun-allowed>
rlisp isn't a Common Lisp implementation, so it couldn't load Quicklisp, or do anything particuarly useful with it.
<jackdaniel>
common lisp code is usually executed after (at least minimal) compilation
<kreyren_>
jackdaniel, cargo-make is arguably a better alternative to `make` reading `Makefile`
<no-defun-allowed>
One does not use Makefiles with Lisp, so it's a bit like designing a better tennis racket for a basketball player.
<kreyren_>
no-defun-allowed, ah you are right that's implementing lisp only.. that still would make it helpful though
yoja has joined #lisp
<aeth>
Every living CL except CLISP is primarily compiled instead of interpreted, and even CLISP is bytecode-compiled first.
<jackdaniel>
if you want to use common lisp with quicklisp, then put the usual steps of installing and loading it in your cargo make; as of running common lisp programs with "rlisp", it is as futile as compiling c++ code with c compiler
<kreyren_>
sm2n, thanks! reference added
<jackdaniel>
at some corner cases doable, however not very good use of ones time
<kreyren_>
no-defun-allowed, i can use common lisp in makefiles though
<aeth>
jackdaniel: and most importantly, ASDF (a dependency of Quicklisp) is not one of those corner cases. It is full of CLOS usage.
<phantomics>
The idea is to implement a system build utility that can build CL systems as part of a larger software system, is that right?
<aeth>
Object systems are one of the main incompatibilities between Lisps, even if you go out of your way to write portability layers.
<jackdaniel>
that has been already implemented in bazel, you may take hints there
<kreyren_>
phantomics, not system build utility this is for a software project management
<kreyren_>
so it may include CI/CD as well
<jackdaniel>
as fun as this discussion is, I can't help but note, that while not literally offtopic, it definetely smells like offtopic ,) see you later
<no-defun-allowed>
It would not, as there is significantly more in a Common Lisp implementation than pure Lisp. Another corny analogy: stacking another bucket of sand on your sandcastle to make a skyscraper is just as helpful.
<kreyren_>
aeth, which would be a concern if they support rustlang?
<kreyren_>
assuming that cargo-make would be able to interpret lisp/common-lisp
treflip` has quit [Quit: ERC (IRC client for Emacs 26.3)]
<sm2n>
kreyren_, wut
<aeth>
kreyren_: I'm not sure what you mean by support... you'd probably CFFI into it using an exported C API.
RedMallet has joined #lisp
<sm2n>
whatever, I am done with this discussion
<aeth>
kreyren_: By "interpret" do you mean "run scripts"? The scripts themselves are probably compiled.
<kreyren_>
aeth, > Object systems are one of the main incompatibilities between Lisps, even if you go out of your way to write portability layers. < -- if they support rustlang and not *lisp then that would allow running lisp on these systems afaik
varjag has joined #lisp
* kreyren_
not sure what you mean by object systems though, my first though was golang
<jackdaniel>
this does not make sense and is definetely offtopic
<no-defun-allowed>
What? Now Go is involved?
<jackdaniel>
kreyren_: I think that this topic better suits the #lispcafe channel
drl has joined #lisp
<jackdaniel>
or, eventually, ##lisp
<no-defun-allowed>
No, please do not take it to #lispcafe
<kreyren_>
aeth, looking at rust-lisp i think that could allow it to be compiled on demand
<aeth>
kreyren_: I mean, how it does OOP (or the lack of OOP) is going to be the main incompatibility with random-cl-inspired-lisp and common-lisp... just like it's the main incompatibility between Schemes.
<jackdaniel>
either way it is offtopic here -- this is a channel dedicated to common lisp, so please move it elsewhere
<kreyren_>
jackdaniel, the main concern is quicklisp on common lisp atm
<kreyren_>
aeth, i am in ##lisp for that if you want
<jackdaniel>
loading quicklisp with common lisp is documented at quicklisp.org, the rest is a matter of calling cl-implementation --load "file-with-source-code.lisp"
<Xach>
quicklisp is a common lisp program. other lisps are not common lisp and are not compatible.
<Xach>
other lisps could be made compatible. it's a lot of work. nobody has done it. common lisp has a lot of features and quicklisp uses a lot of them.
<kreyren_>
jackdaniel, cargo-make is creating a temporary files so those need more arguments usually
<no-defun-allowed>
Yes, but rlisp is NOT a Common Lisp implementation, and making it run Common Lisp code is not much easier than just writing a Common Lisp implementation from scratch.
<Xach>
also, quicklisp uses extra-standard functionality that would also need implementation - networking and filesystem work mostly.
<aeth>
(I mean, some code probably does, but it's an impressive polygot program if it does)
<Xach>
(that's not too hard)
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
<kreyren_>
no-defun-allowed, noted i though that rlisp is common-lisp my bad!
X-Scale` has joined #lisp
<kreyren_>
Xach, is common lisp implemented by design to possibly support non-common lisp or would that need lots of rewriting?
<aeth>
kreyren_: Writing a Common Lisp in Rust is possible, but not easy. There's an effort to write a C++/LLVM Common Lisp called Clasp but it's taking a long time.
<kreyren_>
aeth, noted
<kreyren_>
Xach, sorry meant to say is `quicklisp implemented by design`
<aeth>
Supporting non-CL dialect of Lisp in CL is generally done by writing an implementation of that non-CL dialect of Lisp inside of CL because those dialects are almost always much smaller than CL.
X-Scale has quit [Ping timeout: 265 seconds]
X-Scale` is now known as X-Scale
<kreyren_>
i see
<Xach>
kreyren_: it is implemented by design to take full advantage of Common Lisp and I think trying to make it work elsewhere would be difficult and not very rewarding - since it is meant to allow you to run other common lisp programs, which also are not portable to other lisps.
<Xach>
"Lisp" isn't generic - there are only specifics
<aeth>
Supporting CL features in non-CL Lisps is a much harder route because you'd basically have to implement CL in those languages and it's easier to implement small-in-large than large-in-small.
<aeth>
(Especially since CL will demand some low-level features so you might have to modify the small language's implementation!)
<no-defun-allowed>
kreyren_: Bear in mind that Quicklisp is used to load other Common Lisp code. You may get Quicklisp ported, but for what if you can't run any of the code you use it to download?
<Xach>
I think the ideas of quicklisp are pretty portable, even if the code itself is not especially
<aeth>
Emacs Lisp is the only one that has done what I just described, but (1) it already started out as the closest major Lisp to CL and (2) in decades of doing so, it only has some of CL.
alxplorer has quit [Remote host closed the connection]
RedMallet is now known as treflip
<kreyren_>
Xach, typo will be checked prior to filing to upstream, trying to fix information errors as much as possible atm
Bourne has joined #lisp
<phoe>
"Dialect of Common lisp" → "Implementation of Common Lisp"
<phoe>
Science CL does not exist
<phoe>
rlisp is not an implementation of Common Lisp
<Xach>
"LW" and "LispWorks" refer to the same thing
<phoe>
"possibly more.." does not need to be there - I think you've listed all relevant working implementations, maybe except for SICL which is a work-in-progress
<Xach>
"CCL" and "Clozure CL" also, probably
<phoe>
yes, CCL == Clozure CL
<phoe>
Quicklisp is not one file; the quicklisp.lisp file just downloads everything else from the Internet
davepdotorg has quit [Remote host closed the connection]
<phoe>
"to allow for an implementation-independant code" - that's not the goal of Quicklisp AFAIK, the goal is to make it easy to distribute and update Lisp code over the Internet
<Xach>
My name is not "Zack" and my username is not @xack
<Xach>
Being unaware of information is normal and fine - being sloppy with information is a little more irritating.
* kreyren_
has dislexia so he does these typos often that's why is he letting them to be check by his friend before submitting them x.x
<jackdaniel>
Xack: you are damn right
<kreyren_>
sorry! resolving
<Xach>
at least it isn't mistaken as "Xah" or "Xarch"
<kreyren_>
sorry x.x
<easye>
Come to think of it, I've never seen Xach and Xah Lee in the same Emacs buffer...
<Xach>
No problem - it only remains irritating when something inaccurate is left without correction, or worse, defended as accurate
<kreyren_>
agree
IAmRasputin has joined #lisp
Bourne has quit [Ping timeout: 260 seconds]
<kreyren_>
added disclaimer in case there are things that i've misrepresented
orivej has joined #lisp
IAmRasputin has quit [Ping timeout: 240 seconds]
Stanley00 has quit []
IPmonger has quit [Ping timeout: 240 seconds]
IPmonger has joined #lisp
scymtym has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
toorevitimirp has joined #lisp
davepdotorg has joined #lisp
srhm has joined #lisp
Oddity__ has quit [Read error: Connection reset by peer]
EvW has joined #lisp
narimiran has quit [Ping timeout: 258 seconds]
davepdotorg has quit [Ping timeout: 264 seconds]
EvW has quit [Ping timeout: 240 seconds]
notzmv has joined #lisp
<kreyren_>
Is there any implementation-independent way to get quicklisp through the implementation?
* kreyren_
can't find any on the github and he needs something that can be prepended in cargo-make created files in case quicklisp is not installed to avoid fatal failure
<phoe>
no, there is not
<Xach>
kreyren_: no
<kreyren_>
and it's apparently not possible to implement in implementation independant way right
<Xach>
I think it would be quite a challenge
<kreyren_>
So apparently i can't make easily a code in lisp that would download the file https://beta.quicklisp.org/quicklisp.lisp, but if i package it with cargo-make then what's preventing me from prepending (load #p"~/path/to/quicklisp.lisp") ?
ebrasca has joined #lisp
davepdotorg has joined #lisp
<phoe>
nothing
<phoe>
other than the fact that you will need to manually install quicklisp then.
<phoe>
since this is just an installation script, not a full downloaded instance of quicklisp client.
<kreyren_>
i see x.x
davepdotorg has quit [Ping timeout: 240 seconds]
liberliver has quit [Quit: liberliver]
IAmRasputin has joined #lisp
cosimone has quit [Quit: cosimone]
<phoe>
if anything, your cargo script could either configure quicklisp itself or somehow bundle a Lisp implementation along with its configured quicklisp client
orivej has quit [Ping timeout: 240 seconds]
IAmRasputin has quit [Ping timeout: 256 seconds]
tsrt^ has quit []
<kreyren_>
phoe, that's what i was thinking also, but i try to brainstorm it with upstream
<kreyren_>
would be nice if it could run some tests using these implementations also, but me hit burnout atm
davepdotorg has joined #lisp
liberliver has joined #lisp
liberliver has quit [Client Quit]
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
<phoe>
if anything, you could just depend on a preconfigured Quicklisp-capable Lisp implementation being available and leave configuring this to someone else.
davepdotorg has quit [Ping timeout: 256 seconds]
scymtym has joined #lisp
srhm has quit [Read error: Connection reset by peer]
wsinatra has quit [Quit: WeeChat 2.9]
<kreyren_>
phoe, also yes, but that's meh
saganman has quit [Quit: Leaving]
davepdotorg has joined #lisp
cosimone has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
rogersm has quit [Quit: Leaving...]
srhm has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
IAmRasputin has joined #lisp
Bike has joined #lisp
IAmRasputin has quit [Ping timeout: 256 seconds]
wsinatra has joined #lisp
ebrasca has joined #lisp
EvW has joined #lisp
IAmRasputin has joined #lisp
xrash has joined #lisp
vaporatorius__ has quit [Ping timeout: 265 seconds]
davepdotorg has joined #lisp
frost-lab has quit [Quit: Connection closed]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
liberliver has joined #lisp
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
motersen has quit [Ping timeout: 272 seconds]
motersen has joined #lisp
random-nick has joined #lisp
kreyren_ has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
axion has joined #lisp
beluga0 has quit []
arpunk has quit [Read error: Connection reset by peer]
arpunk has joined #lisp
sr-hm has joined #lisp
srhm has quit [Ping timeout: 264 seconds]
arpunk has quit [Read error: Connection reset by peer]
liberliver has quit [Ping timeout: 240 seconds]
arpunk has joined #lisp
treflip has quit [Remote host closed the connection]
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
alxplorer has joined #lisp
mmohammadi981266 has quit [Quit: I quit (╯°□°）╯︵ ┻━┻]
ex_nihilo has quit [Ping timeout: 260 seconds]
andinus` has quit [Quit: ERC (IRC client for Emacs 26.3)]
catchme has joined #lisp
andinus has joined #lisp
gaqwas has quit [Remote host closed the connection]
alxplorer has quit [Remote host closed the connection]
alxplorer has joined #lisp
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
supercoven has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
Cymew has quit [Ping timeout: 240 seconds]
galex-713 has quit [Ping timeout: 272 seconds]
ex_nihilo has joined #lisp
Bourne has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
rippa has joined #lisp
arpunk has quit [Read error: Connection reset by peer]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
arpunk has joined #lisp
frgo has quit [Ping timeout: 258 seconds]
alxplorer has quit [Remote host closed the connection]
narimiran has joined #lisp
galex-713 has joined #lisp
rgherdt has joined #lisp
galex-713 has quit [Read error: Connection reset by peer]
alxplorer has joined #lisp
arpunk has quit [Read error: Connection reset by peer]
davepdotorg has quit [Remote host closed the connection]
galex-713 has joined #lisp
saganman has joined #lisp
xrash has quit [Read error: Connection reset by peer]
sm2n has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
sm2n has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
arpunk has joined #lisp
alxplorer has quit [Remote host closed the connection]
ex_nihilo has quit [Ping timeout: 260 seconds]
cjv has joined #lisp
cosimone has quit [Remote host closed the connection]
ex_nihilo has joined #lisp
cosimone has joined #lisp
jonatack has joined #lisp
davepdotorg has quit [Remote host closed the connection]
edgar-rft has joined #lisp
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has joined #lisp
zacts_ has joined #lisp
zacts_ has quit [Client Quit]
rumbler31 has joined #lisp
zacts_ has joined #lisp
zacts_ is now known as zacts
zacts has quit [Client Quit]
zacts has joined #lisp
IAmRasputin has quit [Quit: WeeChat 2.8]
sr-hm has quit [Read error: Connection reset by peer]
sr-hm has joined #lisp
sr-hm has quit [Read error: Connection reset by peer]
sr-hm has joined #lisp
mindCrime has joined #lisp
alxplorer has joined #lisp
xale has quit [Quit: Leaving]
ex_nihilo has quit [Quit: Leaving]
sr-hm has quit [Read error: Connection reset by peer]
sr-hm has joined #lisp
alxplorer has quit [Ping timeout: 240 seconds]
skapata has joined #lisp
dbotton__ is now known as dbotton
IPmonger has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
sr-hm has quit [Read error: Connection reset by peer]
sr-hm has joined #lisp
IPmonger has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
aindilis has quit [Ping timeout: 240 seconds]
galex-713 has quit [Ping timeout: 272 seconds]
frgo has joined #lisp
alxplorer has joined #lisp
_paul0 has joined #lisp
alxplorer has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
alxplorer has joined #lisp
paul0 has quit [Ping timeout: 272 seconds]
rogersm has joined #lisp
frgo has quit [Ping timeout: 240 seconds]
zacts has quit [Quit: leaving]
zacts has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
karlosz has joined #lisp
saganman has quit [Quit: Leaving]
alxplorer has quit [Remote host closed the connection]
zacts has quit [Quit: leaving]
sr-hm has quit [Read error: Connection reset by peer]
sr-hm has joined #lisp
zacts has joined #lisp
alxplorer has joined #lisp
zacts has quit [Quit: leaving]
zacts has joined #lisp
treflip has joined #lisp
alxplorer has quit [Remote host closed the connection]
rippa has quit [Read error: Connection reset by peer]
<jcowan>
Language lawyer question: Does it actually break the ANS if an array does not havec O(1) access and mutation in the total-size of the array? Or is that just something taken for granted?
<Bike>
i don't believe the standard specifies timing.
<Bike>
or even mentions constant time as desirable, in fact
<Bike>
the abstract description is pretty much just "An array contains objects arranged according to a Cartesian coordinate system."
colluphid has joined #lisp
catchme has quit [Quit: Connection closed for inactivity]
<jcowan>
Okay. But I think a CL that required O(n) access/mutation would be seen as broken by actual users, or am I wrong?
<jcowan>
(Such a thing is essentially a list of pseudo-pairs on which RPLACD does not work.)
<Bike>
i probably wouldn't use it. maybe it would be necessary on some stupid computer architecture, though.
<jcowan>
Kind of the opposite of cdr-coding (I'm not sure why that idea lost popularity)
liberliver has joined #lisp
<Bike>
doesn't it get weird if you allow mutation. or just shared tails.
<Bike>
also O times are kind of weird these days because the machine has like twelve layers of cache
alxplorer has joined #lisp
zaquest has quit [Ping timeout: 264 seconds]
<jcowan>
Cdr-coding uses a 2-bit tag meaning (a) the cdr is in the next word, (b) the cdr *is* the next word (c) the cdr is nil. If you know the length of the list you want to allocate, you can lay it out as if it were a vector.
<jcowan>
I suppose the answer is that space-saving is not so critical nowadays
<Bike>
also that means cdr branches, which i would count as weird
<jcowan>
vs the time and memory cost of invisible forwarding pointers.
<jcowan>
In the days of microcode, such pointers could be provided at a low level
zaquest has joined #lisp
zacts has quit [Quit: leaving]
alxplorer has quit [Ping timeout: 258 seconds]
<jcowan>
Another possibility, not implemented AFAIK, is "cdr is in the previous word", which would handle construction by CONS as well as by LIST/MAKE-LIST
zacts has joined #lisp
<ebrasca>
I think you can store multiple values in one register
<ebrasca>
Like multiple 8 bit bytes in 64 byt byte register.
sr-hm has quit [Read error: Connection reset by peer]
<pve>
Bike: oh, good point, I should add them
sr-hm has joined #lisp
<Bike>
"If the class metaobject is being initialized, this argument defaults to the empty list." don't need direct slots, i guess
cosimone has joined #lisp
<Bike>
or direct-default-initargs, which is the other one in the example in chapter 5's "Initialization of Class Metaobjects"
<pve>
ok
<Bike>
also, you can set a class's name, so it might be easier to just use defclass and then unset the name
<pve>
right
<pve>
I'm reading the Smalltalk-80 bluebook, and it says that certain metaclasses don't have names, and can only be reached by sending the message "class" to a class. So I'm just checking if that's possible to emulate in CLOS.
<Bike>
yeah, there are explicit provisions for anonymous classes... but it might be kind of inconvenient to arrange.
<pve>
It seems it is possible, though not a critical feature by any means
<pve>
(in my case)
<Bike>
i don't think the MOP people considered it enough, really. Usually you go through ensure-class to make a class, but it sets the binding and stuff for you, so no good for anonymity
EvW has joined #lisp
zacts has quit [Quit: leaving]
<pve>
It's really cool how flexible CLOS/MOP is. I've now been able to make "class messages" work like they should using the metaclasses.
<pve>
Wonder if there is any overlap in the people who made CLOS and the people who made Smalltalk.. the concepts and terminology used are often very similar.
akoana has joined #lisp
scymtym has quit [Remote host closed the connection]
<Bike>
it's not something i've looked into very much, but i think the CLOS predecessor Flavors was more closely based on smlltalk
<Bike>
has messages and stuff
<Bike>
and it was an influence on CLOS obviously
ramHero has quit [Read error: Connection reset by peer]
ramHero has joined #lisp
johnweldon has quit [Read error: Connection reset by peer]
_paul0 has quit [Remote host closed the connection]
jw4 has joined #lisp
paul0 has joined #lisp
alxplorer has joined #lisp
alxplorer has quit [Ping timeout: 260 seconds]
<jcowan>
pve: AFAIK no Smalltalk metaclasses have names, although things like "Number class" are usually treated by humans as if they were names.
<jcowan>
(as well as being Smalltalk expressions)
<jcowan>
The two singularities of Smalltalk are that Object has no superclass and Metaclass class is Metaclass.
narimiran has quit [Ping timeout: 240 seconds]
<jcowan>
So you can say that Metaclass is the only metaclass with a name: it is the parent of Object class, and provides the point at which the metaclass tree connects to the object class tree.
<pve>
jcowan: yeah, I said "certain" because I wasn't a 100% sure
<jcowan>
Sorry, I misstated the singularity: it's the class of Metaclass class that is Metaclass, that is, Metaclass class class is Metaclass.
<pve>
jcowan: It's fine, I know what you meant.. I'm looking at the class diagram now
<pve>
jcowan: to my disappointment, I learned that I won't be able replicate the Metaclass class => Metaclass thing in CLOS
<jcowan>
So if you follow the isubclass-of chain from SmallInteger you get Integer > Number > Magnitude > Object, whereas if you follow the is-a chain from 5 you get 5 > SmallInteger > SmallInteger class > Metaclass > Metaclass class > Metaclass ...
<pve>
yep
<Bike>
you can't make your own parallel hierarchy, but standard-class's class's class is standard-class in a similar way
<Bike>
or, well, its class is itself
<jcowan>
not quite the same
<pve>
Bike: yeah, right now I just say Metaclass is a standard-class and hope for the best :)
<jcowan>
If you are concerned with your own classes only, you can of course make your own metaclass with its own magic.
siloxid has joined #lisp
nekosagan has quit [Ping timeout: 256 seconds]
<pve>
jcowan: I've made a "Metaclass" class whose instances are "Object class" and other used-defined classes' metaclasses, and a "Class" class from which they inherit
* jcowan
nods.
<jcowan>
That's the ticket
srhm has joined #lisp
<pve>
not touching built-in stuff like numbers, packages etc, except by providing a set of methods that map more or less directly to CL functions, so that e.g. "1 + 1 :max 3" works like you'd expect.
rogersm has quit []
<jcowan>
I hope the use of keyword notation means you get to put your keywords in any order desired. It's irritating that ST doesn't allow that.
<pve>
jcowan: sorry :)
<pve>
i try not to stray to far
<jcowan>
oh well
sr-hm has quit [Ping timeout: 246 seconds]
<pve>
*too
<jcowan>
I think there are places in the image where bar:foo: methods are defined on top of foo:bar: methods.
<pve>
Personally, I'm not bothered by the fixed order of keywords
bilegeek has joined #lisp
<jcowan>
It's okay if there aren't too many or if the order makes sense.
dbotton_ has joined #lisp
scymtym has joined #lisp
random-nick has quit [Ping timeout: 256 seconds]
kaftejiman has quit [Read error: Connection reset by peer]
rixard has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
kaftejiman has joined #lisp
rixard_ has quit [Ping timeout: 240 seconds]
gravicappa has quit [Ping timeout: 240 seconds]
alxplorer has joined #lisp
alxplorer has quit [Ping timeout: 260 seconds]
luis has quit [Ping timeout: 256 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
shka_ has quit [Ping timeout: 240 seconds]
alxplorer has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` is now known as X-Scale
alxplorer has quit [Ping timeout: 240 seconds]
alxplorer has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
defaultxr has quit [Quit: WeeChat 2.9]
defaultxr has joined #lisp
ramHero has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
ramHero has joined #lisp
cosimone has quit [Quit: cosimone]
EvW has joined #lisp
sts-q has quit [Quit: ]
zacts has joined #lisp
siloxid has quit [Ping timeout: 260 seconds]
cosimone has joined #lisp
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
rav3n has joined #lisp
zacts has quit [Quit: leaving]
zacts has joined #lisp
v0|d has joined #lisp
sonologico has quit [Remote host closed the connection]
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
motersen has quit [Ping timeout: 240 seconds]
ramHero has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
Steeve has joined #lisp
Jesin has quit [Quit: Leaving]
rgherdt has quit [Ping timeout: 260 seconds]
_jrjsmrtn has joined #lisp
<v3ga>
So i'm rather new to common lisp and just recently getting into lower level web development. If I didn't want to use a CL web server couldn't I just use apache and then a CL routing library and it should work?
__jrjsmrtn__ has quit [Ping timeout: 256 seconds]
<v3ga>
I'm not sure if I worded that correctly...
<no-defun-allowed>
Something like using Lisp as a CGI backend? I don't know if people still do that.
cosimone has quit [Quit: cosimone]
Jesin has joined #lisp
<no-defun-allowed>
There is also mod_lisp on Apache and some other FastCGI libraries, but using a Lisp web server is probably better than the alternative.
zacts has quit [Quit: leaving]
<v3ga>
no-defun-allowed: hmm...
<v3ga>
which would you recommend for dealing with a web app of sorts?
<no-defun-allowed>
I've only ever used Hunchentoot.
<v3ga>
no-defun-allowed: gotcha
<no-defun-allowed>
But I don't write web things unless strictly necessary, so that's probably not a good recommendation.
<v3ga>
no-defun-allowed: it seems to be the most popular..and clack. but then they go into security and other things that just aren't where i'd like them to be. Someone suggested I just throw it yp with nginx backing it...so now i'm looking for some conversation or articles or nginx/apache and common lisp
pve has quit [Quit: leaving]
shifty has joined #lisp
<v3ga>
i'm also seeing people use node.js servers. Truthfully my concerns may be superfluous.
<v3ga>
I think i'm going to toy with 'ningle' and see what comes up.
<White_Flame>
if you want lower level web dev, just open a listening socket and go from there?
rtypo has quit [Ping timeout: 240 seconds]
<v3ga>
White_Flame: truthfully, i'm not sure anymore. I suppose i'm looking for something similar to jetty or kttpkit but not on the jvm
siloxid has joined #lisp
<v3ga>
but also..i'm future proofing when I really may not need to.
<v3ga>
I don't know. Let me shut up for now...i'll come back to it when I have some valid issue or hurdle.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
iissaacc has joined #lisp
madage has quit [Remote host closed the connection]
madage has joined #lisp
<v3ga>
White_Flame: but what were you going to recommend IF I wanted to just deal with sockets?
EvW has quit [Ping timeout: 240 seconds]
takakitan has joined #lisp
srhm has quit [Ping timeout: 240 seconds]
kaftejiman has quit [Remote host closed the connection]