<beach>
We continue writing up issue reports. There is really nothing else to do. When we have a significant list that has been discussed and completed with "current practice" we will probably make a release.
<beach>
Then, implementations that conform can add the label "WSCL x.x compliant".
<beach>
The Current Practice section of the issues would be a fairly easy target for people who want to contribute. It is incomplete in many existing issue reports.
dnhester has quit [Ping timeout: 240 seconds]
bilegeek_ has joined #commonlisp
azimut has quit [Ping timeout: 260 seconds]
bilegeek has quit [Ping timeout: 264 seconds]
adlai has joined #commonlisp
<beach>
It looks like we have around 50 issue reports so far.
<beach>
There are also 19 open GitHub issues that people submit when they don't have enough time to write a complete WSCL issue report, so those could be converted to complete WSCL reports.
<beach>
Oh, I should write up the BOUNDP/MAKUNBOUND problem. It won't be part of a WSCL release, but it is important nevertheless.
<adlai>
out-of-the-loop question -- what is WSCL ?
<ixelp>
GitHub - s-expressionists/wscl: Sources of the "Well Specified Common Lisp" specification which is based on the final dr [...]
<adlai>
thank you beach , both for the authoritative links, and your continuing service to the CL community!
* beach
blushes.
<beach>
Thanks!
<beach>
adlai: Contrary to what some people think, the Common Lisp standard contains a lot of undefined or unspecified behavior that would make almost all existing programs unsafe.
* adlai
was trawling search results, they converge eventually, although there is nothing quite like avoiding argument by direct appeal to authority
<adlai>
one metaphor that might be apt is that the CLtL standards [and even ANSI] were ceasefires between competitors, attained for the benefit of application productivity.
<adlai>
although the war continued, quietly.
<beach>
But I think the war is over though. So it is "safe" to be more strict about specifications.
<adlai>
I doubt you'll find active disagreements about noncompliance cases, within the CL ecosystem, although that is obviously not as good as a strict and explicit document.
* adlai
holds off until studying further
rtypo has quit [Ping timeout: 264 seconds]
<beach>
adlai: Too many negatives in that phrase for my (still sleepy) brain. Can you explain a bit more about the lack of disagreements?
<beach>
adlai: It is not a question of current Common Lisp implementations not being conforming. They probably are mostly conforming.
<adlai>
existing implementations behave in slightly different ways, although humans will probably all agree about what the correct behavior should be.
<adlai>
... however, this state of "probably all agree", in the absence of a strict document, is different from being able to test agreement against that document after it exists.
<beach>
I see, yes.
justache has quit [Ping timeout: 264 seconds]
<adlai>
(* 1/2 N (1+ N)) possibly endless arguments in the absence of any document, compared to N binary outcomes once there is a document.
justache has joined #commonlisp
<beach>
Got it!
mm007emko has quit [Ping timeout: 264 seconds]
mm007emko has joined #commonlisp
bilegeek_ has quit [Quit: Leaving]
Pixel_Outlaw has quit [Remote host closed the connection]
chomwitt has joined #commonlisp
johnjaye has quit [Ping timeout: 264 seconds]
johnjaye has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
pve has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
<resttime>
Any idea if there'd be better performance if vector math was implemented with multiple values versus a simple 1D array?
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
igemnace has joined #commonlisp
son0p has quit [Read error: Connection reset by peer]
istewart has quit [Quit: Konversation terminated!]
traidare has joined #commonlisp
<adlai>
resttime: I think such questions are invariably dependent on implementation details; however, humans are better at recognizing possible optimizations when assumptions are explicit in the code, in this case, defined types for compound data rather than simply a bunch of values adjacent on the stack.
<adlai>
additionally, my experience has invariably been that splitting one compound datum into multiple values on the stack is counterproductive outside of narrow internal functions. it makes the resulting functions less composable, and you begin wishing that you were working in forth or factor rather than lisp.
<adlai>
I find multiple values good for when they are either separate things that don't get intuitively considered as one compound datum, or multiple views on the same datum, with the default one used by the code as the 0th return value, and subsequent views available in (cdr /) for interactive convenience at the REPL.
* adlai
realizes that statement is contrary to e.g. CL:FLOOR ; however, that would be an example of a really narrow function
<adlai>
returning to resttime 's specific question, SIMD instructions in your CPU are more likely to play nicely with specialized arrays, than with whatever convention the implementation uses for values on the stack.
rgherdt has joined #commonlisp
elderK has quit [Quit: WeeChat 4.1.1]
varjag has joined #commonlisp
notzmv has quit [Ping timeout: 264 seconds]
rbcarleton has quit [Remote host closed the connection]
rbcarleton has joined #commonlisp
Inline has quit [Quit: Leaving]
msavoritias has joined #commonlisp
mm007emko has quit [Read error: Connection reset by peer]
mm007emko has joined #commonlisp
alcor has joined #commonlisp
ec has quit [Ping timeout: 260 seconds]
ec has joined #commonlisp
dino_tutter has joined #commonlisp
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
Inline has joined #commonlisp
<alcor>
Interestingly, the Lem Editor (& CL IDE) is now available as an ocicl package: https://github.com/ocicl/lem
<beach>
Top-level comments have 3 or 4 semicolons. Full-line comments inside a function have 2 semicolons.
<beach>
There is never any whitespace after ( nor before ).
<chsasank>
thanks
<chsasank>
what about load thingy I used
<beach>
It is much better to create an ASDF system definition that to have explicit LOADs in the code.
<aeth>
dependencies are typically handled through a top level .asd file... the only thing at the top of any file is typically an in-package and, if the package is defined in the same file instead of in a separate package.lisp, a defpackage above the in-package
<aeth>
but the majority style seems to be one package.lisp per directory
<ixelp>
Defining Systems
<beach>
chsasank: Yes.
<chsasank>
thanks, will read and change it.
<beach>
Also, there is no need for more than one blank line between two top-level forms.
<beach>
Horizontal space is a precious resource.
random-nick has joined #commonlisp
<chsasank>
any style guide on spacing?
<chsasank>
I would like to use some autoformatted like black in python
<beach>
Just the one above about ( and ) and one space between each sub-expression of an expression.
son0p has joined #commonlisp
<beach>
You should define accessors for your rules, rather than littering the code with FIRST and SECOND. You could call those accessors LHS and RHS for instance.
<chsasank>
got it, norvig does it all the time in his textbook
<beach>
Everybody should do it. When you get a bit more advanced, you can use a standard class to define your rule, rather than representing it as a list.
<chsasank>
norvig uses macros
<beach>
For accessors? I doubt it.
chomwitt has quit [Ping timeout: 260 seconds]
<chsasank>
so defining new rules
<beach>
For defining rules, a macro is fine. But that's not an accessor.
<chsasank>
yes, not for acccessors
<chsasank>
he does macros prob because he doesn't want to put quotes
<beach>
So, you should define a constructor as well, like MAKE-RULE, rather than using explicit lists.
<beach>
That way, the representation of a rule is in a single place, so you can easily change the representation later on.
<beach>
But that's a general programming rule, and not specifically for Common Lisp.
<chsasank>
got it
shka has joined #commonlisp
<beach>
Can I assume you have programming experience using other languages?
<chsasank>
sort of pro in python yeah
<beach>
OK, so then rules like this won't come as a surprise.
<chsasank>
no sure :)
<chsasank>
I'm just hacking rn
<chsasank>
I am not even sure if these will be useful 😅
<alcor>
Shouldn't that be `defconstant', beach? Not familiar with the problem domain but I don't think a list of static transformation rules should be dynamically rebindable
<chsasank>
norvig uses defparamaters so that his add-rule macros add to the param
<chsasank>
my knowledge of lisp = paip
<beach>
alcor: Maybe, but it is iffy to use DEFCONSTANT with things other than very simple stuff like numbers and characters.
random-nick has quit [Ping timeout: 260 seconds]
<chsasank>
since I have your attention, the most important problem I have rn is compiling for-loop form
<aeth>
I tend to eliminate intermediate variables that only exist to be intermediate, e.g. I have a (destructuring-lambda (...) ...) that combines (lambda (x) (destructuring-bind (...) x ...)) except obviously using a gensym so x isn't there
<aeth>
but obviously destructuring-bind binds
<chsasank>
interesting
<chsasank>
this for your SPIR-V gen project?
<aeth>
just a utility macro in general
traidare has joined #commonlisp
rbcarleton has quit [Remote host closed the connection]
rbcarleton has joined #commonlisp
<chsasank>
got it
<aeth>
e.g. (mapcar (destructuring-lambda (x y (&key z &allow-other-keys)) (list z y x)) '((3 4 (:z 5)) (8 7 (:w 6 :z 5)))) => ((5 4 3) (5 7 8))
<aeth>
useful for writing macros
<chsasank>
I have been thinking about your comments about SSA from yesterday
<beach>
chsasank: I think I need to leave remarks up to others. I am a slow learner, so it would take way too much of my time to read and understand the code and the documentation, at least with the current state of it.
<chsasank>
basically use gensym for intermediate numbers
<chsasank>
Thanks beach. FL is very weird.
<chsasank>
I need to do a good job of making it clearer
<chsasank>
aeth: so SSA is opposite of what I want to do. In SSA you create names for every small intermediate form and leave 'register allocator' to deal with it
<chsasank>
this kinda seems like a BS thing to do because register allocation = graph coloring = NP hard problem
<chsasank>
I know that downstream optimizations can benefit from it. But Wirth says generate good code the first time around and don't rely on optimizations
danse-nr3 has joined #commonlisp
<aeth>
the keyword being "intermediate". (+ (* a (expt x 2)) (* b x) c) defines no new variables in the function (defun polynomial (x a b c) (+ (* a (expt x 2)) (* b x) c))
<aeth>
but that's the same as (defun polynomial (x a b c) (let* ((g1 (expt x 2)) (g2 (* a g1)) (g3 (* b x)) (g4 c) (g5 (+ g2 g3 g4))) g5))
<aeth>
or should be, anyway. Humans aren't very good at that transformation
<chsasank>
correct. in your example, all the intermediate variables gi can actually be stored in one single register
<aeth>
and if you're generating an SSA IR for, say, SPIR-V, then you want a LET or LET* of your own so you can keep track of all of the intermediate stuff that you need to refer again later, but only once or twice, in a limited scope
<chsasank>
have a CPS and later transform to SSA
<chsasank>
that's how I would do it
<aeth>
lambda and let are in this case equivalent, but let is easier to work with, especially if you need the let* variation where I think that's equivalent to nested lambdas (maybe curried?)
<chsasank>
agreed, let is easier to manipulate
<beach>
What would be the point of SSA if there are no assignments? If there are no assignments, the code is already SSA.
<chsasank>
we need to eventually translate to earthly machines :)
<aeth>
beach: generally because you're generating code for someone else's IR (e.g. SPIR-V for OpenGL/Vulkan/OpenCL GPU stuff) and they already decided on SSA because LLVM did it
<aeth>
if not just generating LLVM IR, which is also quite popular
<beach>
But if your code is already SSA, there is no need to transform it.
mgl has joined #commonlisp
<chsasank>
so your machine will not support same functional primitives as your language
<chsasank>
machine will have different instruction set (or functional primitives)
<chsasank>
your code needs to get transformed to these
donleo has joined #commonlisp
<resttime>
adlai: cool, makes sense. it was an question that popped in my head when thinking about different ways of eliminating cons'ing
<aeth>
beach: the transform is, except on branching (or setting, I guess?), necessary but it's just walking in evaluation order (by basically evaluating)... it's pretty simple
<aeth>
you still need to transform on branching but it's not the same sort of simplicity
<aeth>
GPU-oriented stuff barely branches, though
<aeth>
and I think I can get away with entirely pure functions in shaders except for setting the output value (which is really just the structure of the shader IR and is more of a return than a set)
<beach>
aeth: It looks like you know this stuff, so I'll leave remarks to you.
<aeth>
I'm not sure if the semantics of FL are similar
<aeth>
also I think chsasank is targeting GPU compute kernels rather than OpenGL/Vulkan shaders. So some things may differ
<chsasank>
aeth: it might interest you to know some of the recent compilers are target so called compute shaders
<aeth>
but for my case, I can basically just evaluate (my-package:+ (my-package:* a (my-package:expt x 2)) (my-package:* b x) c) and the SSA form follows from that, with the return value metadata being the thing that's returned and the instructions being generated in a dynamic/special variable side effect
<chsasank>
I need to probably use compute/opencl spir-v because that's what my gpu supports oob
<chsasank>
need to benchmark the difference b/w two approaches
<Mon_Ouie>
resttime: In my experience with SBCL, it is pretty good at eliminating consing if you just (declare (dynamic-extent …)) your vectors, although it does tend to still have redundant load/store of the intermediate results
<aeth>
ime with SBCL, consing is commented in the disassem so you can read the comments of the DISASSEMBLE and see if it's consing or not even if you're not reading the assembly
<aeth>
there are several ways to profile it, too, but the diassemble makes it pretty clear
<aeth>
chsasank: if you're generating SPIR-V, yes, the compute kernel SPIR-V has some changed semantics, but you can probably use the same generation strategy that I do
random-jellyfish has joined #commonlisp
<chsasank>
yes, when I get to SSA your code gonna be my backend :)
random-jellyfish has quit [Remote host closed the connection]
<aeth>
that is, append instructions to a special/dynamic variable in evaluation order as a side effect while evaluating what the return value is as the actual return value.
<chsasank>
if only I have more runtime options in SBCL :(
<ixelp>
GitHub - kiselgra/c-mera: Next-level syntax for C-like languages :)
<aeth>
well, I'm kind of bogged down in cleaning up my representation of SPIR-V types so I can get things clear enough for branching and logic, at which point that's most of SPIR-V
<chsasank>
ever used it?
<aeth>
Not quite a complete SPIR-V because there's iteration, too. Again, weird to put off branching and iteration, but shaders are weird.
<aeth>
chsasank: I don't need to generate C. I can probably get by with just generating SIMD asm via SB-SIMD, which is a much easier way to do it than the old way to generate SIMD (directly using asm) in SBCL. https://github.com/sbcl/sbcl/tree/master/contrib/sb-simd
<aeth>
With a portable fallback when SIMD is unavailable, such as on other implementations.
<aeth>
Some of my pointless generalization that makes it look like my progress stalled is so I can go SPIR-V->SIMD and SPIR-V->fallback
<aeth>
though it won't be particularly optimized SIMD
<chsasank>
ok
<chsasank>
wouldn't be nice if sbcl can work on GPUs :P
<aeth>
I'm not sure how you'd represent a dynamic type. You can do it, sure, it's Turing complete so you can do anything. But the obvious way of doing it (tagged union) doesn't appear to exist in SPIR-V.
<chsasank>
ok not yet expert of spir-v
<chsasank>
for now x86 asm for me :)
<aeth>
You can, for instance, emulate a tagged union in a memory-inefficient way with a struct... basically allocating the space for all of the types at once even though only one is nonzero :-)
<chsasank>
I might end up having to make another DSL for rewrites :o
<resttime>
Mon_Ouie: yeah, i think i need to rewrite how my some of my math done. It's hypothetical situations like (vec+ (make-vec3 1 2 3) (make-vec3 1 2 3)) that I've been thinking about how to handle
<aeth>
maybe the libraries beach is working on can be thrown on top of a GPU DSL to create a working CL... but probably not easily out of the box because beach doesn't believe in the approach to start with a CL subset iirc
<resttime>
Ideally only vec3 is made/cons'd (the resulting vec3 from the addition)
<Mon_Ouie>
resttime: The way I've been trying to solve that is to keep track of function that "consume" vectors without storing them, and functions that always return fresh vectors
<aeth>
resttime, Mon_Ouie: My solution for this is going to be complete and total overkill, but when you have a hammer...
<Mon_Ouie>
And use a compiler macro so that, if the argument of a function that consumes a vector is a call to a function that returns a fresh vector, add (declare (dynamic-extent …))
<chsasank>
oh that's beach! His libs got referred a lot here!
<beach>
There are a bunch more in the s-expressionists repository.
notzmv has joined #commonlisp
<aeth>
resttime, Mon_Ouie: In my personal case, I've realized that if I run my vector code on the CPU through the same middle stage as my shader DSL, I should have an incredibly overkill version of something that lets you do (+ (vec 1f0 2f0 3f0) (vec 4f0 5f0 6f0))
<aeth>
or, rather, something like (with-zrsl (+ (vec 1f0 2f0 3f0) (vec 4f0 5f0 6f0))) where it does the incredible overkill of turning it into SPIR-V just to turn it back (rather than putting it on the GPU)
<resttime>
Mon_Ouie: hmmmm had a hunch macro would be needed
<aeth>
resttime: you'd want a macro around the whole thing, I think, to make it clear you're walking. It also lets you reinterpret e.g. cl:+ to your-lib:vec+ within the macro
<aeth>
if you choose to do it that way, anyway
<aeth>
you can probably just simply error on anything that's not convertible arithmetic or a variable or a constant
<resttime>
👌
<aeth>
the hard part about code walkers are when you encounter arbitrary macros
<aeth>
so just don't do that, don't work on CL in general
<aeth>
you'd still want the inelegant version of all of your stuff like vec+, though, because otherwise you don't have anything to generate from the code walker
traidare has quit [Ping timeout: 264 seconds]
<aeth>
Mon_Ouie: if you code walk and it's constant like (vec3 1f0 2f0 3f0) you can propagate it like a compiler and if it's something like (vec3 x y z) instead of turning it into a dynamic-extent you can turn it into (multiple-value-bind (x y z) ...) and avoid consing entirely (but now you need multiple value versions of your linear algebra functions, too)
<aeth>
(not all of them... it'd probably be pointless to do this for matrices)
<aeth>
and when mixed e.g. (vec+ actual-vector multiple-value-vector) you can decompose the first vector into values. For my code, I could do something like (multiple-value-call #'vec3+/mv (array-of-3 actual-vector) multiple-value-vector)
iska has joined #commonlisp
iska has left #commonlisp [#commonlisp]
traidare has joined #commonlisp
edgar-rft has quit [Quit: don't waste your life by reading this]
rbcarleton has quit [Remote host closed the connection]
rbcarleton has joined #commonlisp
alcor has quit [Remote host closed the connection]
alcor has joined #commonlisp
amb007 has quit [Ping timeout: 246 seconds]
amb007 has joined #commonlisp
ronald has quit [Ping timeout: 252 seconds]
ronald has joined #commonlisp
igemnace has quit [Read error: Connection reset by peer]
parens-user has joined #commonlisp
tok has quit [Ping timeout: 255 seconds]
danse-nr3 has quit [Ping timeout: 260 seconds]
igemnace has joined #commonlisp
<paulapatience>
beach: There are two spaces before *FEATURES* in the problem description of the variables-that-influence-the-lisp-reader issue.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
tyson2 has joined #commonlisp
pfdietz has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
yitzi has joined #commonlisp
green__ has quit [Ping timeout: 268 seconds]
Oddity has quit [Ping timeout: 260 seconds]
chomwitt has joined #commonlisp
johnjaye has quit [Ping timeout: 268 seconds]
johnjaye has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
danse-nr3 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
josrr has joined #commonlisp
chomwitt has quit [Ping timeout: 260 seconds]
green__ has joined #commonlisp
green__ has quit [Ping timeout: 268 seconds]
green__ has joined #commonlisp
cmack has joined #commonlisp
a51 has joined #commonlisp
justache has quit [Ping timeout: 264 seconds]
<beach>
Thank you. Fixing...
justache has joined #commonlisp
<beach>
Pushed.
rgherdt has quit [Remote host closed the connection]
rgherdt has joined #commonlisp
rtypo has joined #commonlisp
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
alcor has quit [Ping timeout: 264 seconds]
holycow has quit [Quit: Lost terminal]
johnjaye has quit [Ping timeout: 260 seconds]
johnjaye has joined #commonlisp
justache has quit [Ping timeout: 264 seconds]
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
occ has joined #commonlisp
justache has joined #commonlisp
alcor has joined #commonlisp
azimut has joined #commonlisp
traidare has quit [Ping timeout: 246 seconds]
rgherdt_ has joined #commonlisp
chomwitt has joined #commonlisp
rgherdt has quit [Ping timeout: 264 seconds]
ymir_ has joined #commonlisp
rbcarleton has quit [Remote host closed the connection]
rbcarleton has joined #commonlisp
josrr has quit [Remote host closed the connection]
danse-nr3 has quit [Ping timeout: 252 seconds]
josrr has joined #commonlisp
yitzi has quit [Remote host closed the connection]
tyson2 has quit [Remote host closed the connection]
occ has quit [Ping timeout: 260 seconds]
green__ has quit [Remote host closed the connection]
green__ has joined #commonlisp
occ has joined #commonlisp
chomwitt has quit [Ping timeout: 272 seconds]
kevingal has joined #commonlisp
ymir_ has quit [Ping timeout: 246 seconds]
dnhester has quit [Ping timeout: 256 seconds]
zetef has joined #commonlisp
danse-nr3 has joined #commonlisp
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
josrr has quit [Remote host closed the connection]
josrr has joined #commonlisp
occ has quit [Ping timeout: 264 seconds]
eddof13 has joined #commonlisp
josrr has quit [Remote host closed the connection]
josrr has joined #commonlisp
a51 has quit [Quit: WeeChat 4.2.1]
edgar-rft has joined #commonlisp
igemnace has quit [Quit: WeeChat 4.2.1]
dnhester has joined #commonlisp
alcor has quit [Read error: Connection reset by peer]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
dnhester has quit [Ping timeout: 264 seconds]
alcor has joined #commonlisp
jjnkn has joined #commonlisp
eddof13 has quit [Quit: eddof13]
dnhester has joined #commonlisp
danse-nr3 has quit [Read error: Connection reset by peer]
danse-nr3 has joined #commonlisp
dnhester has quit [Ping timeout: 255 seconds]
eddof13 has joined #commonlisp
Lycurgus has joined #commonlisp
traidare has joined #commonlisp
dnhester has joined #commonlisp
danse-nr3 has quit [Ping timeout: 268 seconds]
chsasank has quit [Ping timeout: 260 seconds]
dnhester has quit [Ping timeout: 264 seconds]
chomwitt has joined #commonlisp
X-Scale has joined #commonlisp
Inline has quit [Quit: Leaving]
wbooze has quit [Quit: Leaving]
dnhester has joined #commonlisp
tyson2 has joined #commonlisp
chomwitt has quit [Ping timeout: 268 seconds]
synchrom1 has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
msavoritias has quit [Ping timeout: 272 seconds]
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
istewart has joined #commonlisp
Inline has joined #commonlisp
wbooze has joined #commonlisp
dnhester has quit [Ping timeout: 264 seconds]
Oddity has joined #commonlisp
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
<younder>
plist to alist: (loop for (key val) on plist by #'cddr collect (key . val))
random-nick has joined #commonlisp
a51 has joined #commonlisp
pve has quit [Quit: leaving]
<younder>
Been handling the 'dreaded' table row update which works for any table. Handles if the table has a index which it gets from table-description.
<younder>
(defun store-table (table-name pre-change post-change) ...) where pre-change and post-change are plist of row values
<younder>
hunchentoot:post-parameters returns a alist..
jjnkn has quit [Quit: leaving]
<josrr>
younder: there are alexandria:alist-plist and alexandria:plist-alist functions. Alexandria is probably already in your dependencies.
zetef has quit [Remote host closed the connection]
<younder>
joshrr it is. I forgot about those thx
rbcarleton has quit [Remote host closed the connection]
rbcarleton has joined #commonlisp
Pixel_Outlaw has joined #commonlisp
elderK has quit [Quit: WeeChat 4.1.1]
wacki has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
tyson2 has joined #commonlisp
<Pixel_Outlaw>
Hello all, is there an option to write a GUI app for android? I've got cl-repl on my phone which I believe runs on Qt but I'm not sure if you can write new programs on the phone and test them.
<Pixel_Outlaw>
Just thought somebody might have tried similar. It's fairly nice to write on the phone itself with a keyboard.
alcor has quit [Remote host closed the connection]
<josrr>
Pixel_Outlaw: AFAIK, you need to use a computer to write an application with lqml.
shka has quit [Ping timeout: 255 seconds]
attila_lendvai has quit [Ping timeout: 240 seconds]
eddof13 has joined #commonlisp
<Pixel_Outlaw>
OK, still it's nice to know it's possible. It'd be nice to get some real software on Android rather than Fisher-Price 3 button baby toys.
tyson2 has quit [Remote host closed the connection]
dra has joined #commonlisp
zaymington has quit [Remote host closed the connection]
zaymington has joined #commonlisp
ebrasca has quit [Remote host closed the connection]
Renfield has joined #commonlisp
dra_ has joined #commonlisp
dra has quit [Read error: Connection reset by peer]
rgherdt_ has quit [Remote host closed the connection]