lnostdal has quit [Read error: Connection reset by peer]
fikka has joined #lisp
biopandemic has quit [Quit: Quit.]
fikka has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
Fare has joined #lisp
<pillton>
Fare: I know of it but I had difficulty following the paper.
Fare has quit [Ping timeout: 276 seconds]
dale has joined #lisp
edgar-rft has joined #lisp
meepdeew has joined #lisp
sjl has quit [Ping timeout: 260 seconds]
<pillton>
Actually, what I really mean, I had difficulty mapping lisp-interface-library to the problems I have.
<stylewarning>
LIL to me was the introduction of a new paradigm to Common Lisp, not a library to fulfill the needs of an existing paradigm
<stylewarning>
it does enable different sorts of polymorphism, but doesn't map syntactically to any usual way of thinking about polymorphism (imo)
<stylewarning>
Haskell type classes, for instance, eventually map to an interface-passing style mechanism under the hood, but it's not something you ever see or are exposed to as a user
housel has quit [Read error: Connection reset by peer]
test1600 has quit [Quit: Leaving]
housel has joined #lisp
nowhereman_ has quit [Ping timeout: 256 seconds]
nowhere_man has joined #lisp
<PuercoPop>
Fare: looking into the quake source code I see some code for the alloy-mode, but I'm unsure what was the use case of alloy, to help model the DB?
nowhere_man has quit [Ping timeout: 244 seconds]
dale has quit [Quit: dale]
Kundry_Wag has joined #lisp
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
_whitelogger has joined #lisp
housel has quit [Read error: Connection reset by peer]
housel has joined #lisp
sabrac has joined #lisp
<sabrac>
Hello all
renzhi has quit [Quit: WeeChat 2.1]
acolarh has joined #lisp
lumm has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
Fare has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Oladon has joined #lisp
torbo has joined #lisp
Oladon has quit [Ping timeout: 244 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
quazimodo has quit [Ping timeout: 276 seconds]
renzhi has joined #lisp
igemnace has joined #lisp
marvin2 has quit [Ping timeout: 276 seconds]
pierpa has quit [Quit: Page closed]
housel has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
dddddd has quit [Remote host closed the connection]
torbo has quit [Read error: Connection reset by peer]
<PuercoPop>
At long last my XCB client can send and read the setup request. Now I have to think how to reify the XCB types, probably as CLOS classes. I've seen the Elisp client uses the slots in a class as 'schema' but one can't assume the slot order is they are 'written in code' right? Plus I don't want to keep the padding bytes in slots if I can avoid it.
<sabrac>
Agree the slot order is not specified, so you cannot rely on the order in the written code
Kundry_Wag has joined #lisp
<PuercoPop>
I've been thinking of maybe writing the schema filter padding fields before defining the corresponding class
Kundry_Wag has quit [Ping timeout: 256 seconds]
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
vtomole has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
meepdeew has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
_whitelogger has joined #lisp
vtomole has quit [Ping timeout: 252 seconds]
nebunez has quit [Ping timeout: 265 seconds]
kirkwood has joined #lisp
SaganMan has quit [Ping timeout: 255 seconds]
orivej has quit [Ping timeout: 272 seconds]
SaganMan has joined #lisp
slyrus1 has quit [Ping timeout: 244 seconds]
pillton has quit [Ping timeout: 240 seconds]
slyrus1 has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
robotoad has joined #lisp
megalography has joined #lisp
anewuser has quit [Quit: anewuser]
captgector has quit [Ping timeout: 268 seconds]
captgector has joined #lisp
igemnace has quit [Quit: WeeChat 2.2]
<beach>
Good morning everyone!
igemnace has joined #lisp
<no-defun-allowed>
afternoon beach
sauvin has joined #lisp
vlatkoB has joined #lisp
Inline has quit [Quit: Leaving]
housel has joined #lisp
kdas_ has joined #lisp
kushal has quit [Ping timeout: 250 seconds]
dented42 has joined #lisp
gigetoo has quit [Ping timeout: 272 seconds]
funnel has quit [Ping timeout: 256 seconds]
funnel has joined #lisp
gigetoo has joined #lisp
kdas_ is now known as kushal
tralala has joined #lisp
beach has quit [Disconnected by services]
beach has joined #lisp
impulse has quit [Ping timeout: 260 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Fare has quit [Ping timeout: 272 seconds]
<schweers>
Good morning beach o/
light2yellow has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
<zigpaw>
morning :)
* schweers
sighs
<schweers>
I’m not sure it was a good idea to read the unix haters handbook
<beach>
Why? It is brilliant.
<beach>
I didn't read it for the longest time because I thought it would be something written by random complainers.
<beach>
But these guys are very knowledgeable and very smart. They know their computing history.
<schweers>
I’m not sure its brilliant, but it does shed some light on areas of unix which I previously did not critically examine
<schweers>
I sometimes wish for more commentary on how this should be instead, but nevertheless, it is an interesting read.
<schweers>
It just doesn’t make me a more happy person :D
<beach>
It is brilliant because it accurately points out many things that we knew how to do before Unix, and that are now done wrong.
<schweers>
I saw a talk yesterday (on youtube) about how to do privilige separation on unix
<schweers>
and my god is it horrible
<schweers>
and the guy didn’t seem to think it was /that/ bad.
<beach>
Oh, I agree that the book depressing in many ways. But the way the computing domain has turned out is depressing. That's why I am trying to do something about it.
<schweers>
I first heard of the book when I was starting out with linux. back then I came from windows, which I still find worse.
<beach>
Well, I won't be able to change anything, but at least I will know what should have been done instead.
<schweers>
I am very grateful for that. Thanks a lot!
mange has quit [Ping timeout: 276 seconds]
<schweers>
you’re working on a Lisp based OS, right?
<schweers>
(among other things)
Fare has joined #lisp
<beach>
Yes, among other things. :)
<beach>
A better Common Lisp implementation, a better debugger, a better editor, ...
<schweers>
I worry that even if your Lisp OS is the greatest thing ever, and it done by tomorrow, it won’t pick up much market share. Simply because our industry is already fubar :(
<beach>
That's what I meant when I said I won't be able to change things, but I will know what should have been done instead.
<schweers>
maybe you can change things for a few people
<schweers>
I wonder: how difficult would it be to run programs not written in lisp on such an OS?
<Shinmera>
Mezzano already runs Quake and Doom :)
<schweers>
please correct me if I’m wrong, but this is how I understand it: by focussing on C so much, unix became kind of language agnostic. I wonder how this would work an OS which focusses on any higher level language.
<schweers>
by some sort of emulation, or natively?
<Shinmera>
Unix is not language agnostic at all. It's very C-bound.
<schweers>
Well, you don’t have to program in C just to interact with the kernel.
<Shinmera>
No, but you don't need to program in Lisp to run a lisp routine either. It's all ASM at the bottom.
<schweers>
I wonder how to properly translate C to lisp, as C relies so heavily on the fact that memory is flat and has poor access restrictions.
<jackdaniel>
I'm working on an interesting problem: copying array region into itself (with possible overlap)
<jackdaniel>
implementation is not hard, but to have a proper test coverage is fun
<lieven>
symbolics came with a C compiler. it's often invoked in C standard debates to show that the NULL pointer isn't guaranteed to have all bits 0 and can't be initialized with calls to calloc
<schweers>
that I get, but how does one exchange data? in a simple format not unlike what is done in C-land?
<Shinmera>
You need conversion routines, just like you need for any kind of bridge.
<schweers>
This sounds a lot less scary than I initially thought. So thanks for the clarification :)
<Shinmera>
It's really astounding to me how ingrained this idea has become in people's minds that "C is simple" and that everything else is somehow special.
<schweers>
guilty as charged :/
<schweers>
trying to break free of it though
<lieven>
schweers: for example, a lot of those poor access restrictions you're talk about in C aren't guaranteed by the standard
<jackdaniel>
I like C though I have one complaint – control of the function argument stack should be on the calee, not the caller
<jackdaniel>
then it would be a very acceptable assembler
<lieven>
schweers: try running C on an AS400 or whatever it's called nowadays
<schweers>
Ah yes, another problem: the C I have in my head is C on linux on x86, not the language standard.
<jackdaniel>
(and the programmer should have access to this part of the stack)
<schweers>
I guess I’m not the only one
<schweers>
I find it really weird that C does not have access even to very simple parts of the processor, like the carry flag
<schweers>
well, overflow would be more important, but you get the idea
<schweers>
I guess this is because I don’t know how other architectures worked
<lieven>
to be fair, most of these other architectures now are dead or very niche
<schweers>
nevertheless they were once relevant. And other architectures may become more relevant again in the future.
robotoad has quit [Quit: robotoad]
<lieven>
C on VM/SP did not have a stack but as mandated by that system's ABI a chain of activation records
<schweers>
I guess this is why the standard does not mention the stack at all
igemnace has joined #lisp
<Shinmera>
The PDP-11 did have an overflow flag
<lieven>
IBM's "lisp" implementation on VM/CMS was really a tentacled horred
<lieven>
*horror
<Shinmera>
Which IIRC is what C was initially conceived on?
<beach>
schweers: The way I see it is, in order to run a C program on the kind of OS I would like, it would have to behave like a single Common Lisp function, and it would have to communicate with other functions just like in Unix, i.e. with something like file descriptors.
<schweers>
Shinmera: I think so, yes
<schweers>
I’m beginning to understand what it is like to have drunk the kool-aid
xantoz has quit [Ping timeout: 256 seconds]
impulse has joined #lisp
<Bike>
learning hardly anything about Forth helped me with understanding C
<schweers>
forth is and was interesting to me because it induces a shift in perspective. Lisp obviously did too.
shka_ has quit [Quit: Konversation terminated!]
shrdlu68 has joined #lisp
<Bike>
i mean things like the create word. when i learned that i was like oh, that's "lower level" than C (not knowing about alloca at the time)
<schweers>
is alloca standard?
<Shinmera>
alloca isn't standard C anyway
<Bike>
see, there you go.
<Shinmera>
It's a GNU stdlib extension if I remember correctly.
<Bike>
not create. allot. whatever it is. i haven't actually USED much forth
sunset_NOVA has joined #lisp
SaganMan has quit [Ping timeout: 256 seconds]
<varjag>
Shinmera: dates back to bell labs unix
<schweers>
the “CONFORMING TO” section of the man page I have here on debian is scary.
orivej has joined #lisp
shka_ has joined #lisp
SaganMan has joined #lisp
shka_ has quit [Client Quit]
shka_ has joined #lisp
<lieven>
Thinking Forth by Brodie is a great book even if you have no intention to ever use Forth
<jdz>
True story (I recently read it).
<schweers>
I believe I started reading that one, finding it really weird.
Bike has quit [Quit: Lost terminal]
<lieven>
jdz: and how did you like it?
<schweers>
maybe it was because I was hoping for the book to be more about forth itself.
<lieven>
schweers: his other book teaches the language: Starting Forth
<jackdaniel>
while I admire forth very much (and rather like C), I'm afraid we stray from the channel topic forther and forther ;)
<schweers>
yeah, I know. I was having a hard time understanding the more interesting features of forth and was hoping for more (and different?) explanations.
<jdz>
I have not done any Forth programming, and cannot be considered a real programmer since I have not even implemented a Forth interpreter.
<schweers>
lol
<lieven>
jackdaniel: up to a point. in a way lisp and forth are two languages that very much support building up your language to address the problem domain. they're both programmable programming languages where you have (most of) the tools of the language implementor at hand for your own work
<Shinmera>
Regardless, it isn't Common Lisp.
<jackdaniel>
Imo if we refuse to talk scheme or clojure here, forth may be considered not common-lispy enough too :-)
<shka_>
good morning
<schweers>
we could discuss whether forth is closer to common lisp than scheme. Or we could simply not ;)
<schweers>
is it just my impression, or is compiling Lisp code really pretty fast, even with SBCL?
<schweers>
compared to other languages, of course
<beach>
Well, you don't have the problem that C++ does with huge header files.
<beach>
So it can very well be true.
<schweers>
well, C++ is probably the worst offender
<dim>
well it depends, I think the fact that we often compile a small chunk at a time interactively makes it for a very low-latency feedback loop and it then seems very fast
<shka_>
schweers: also, note that you usually compile just one piece of code at the time
<schweers>
I find it quite fast even when I empty the cache (~/.cache/common-lisp) and load my whole system it is reasonably fast.
<loke>
Try clearing all the compile caches and then compile McCLIM on ECL.
<dim>
C/C++ is very stupid with the lack of “modules”
<loke>
That take sminutes
<schweers>
So it even builds all the libraries I depend on
<shka_>
there are a lot faster languages to compile anyway
<shka_>
but yeah, sbcl compilation speed is good enough most of the time
<loke>
But, on the other hand CCL, is very fast at compiling.
<schweers>
hm, so it seems my impression is only partly correct. Nevertheless, it’s not extremely slow as one might naively expect
<dim>
almost twice as fast as SBCL on my experience, with default settings
<aeth>
The problem with CL compilation is that it is not parallel and afaik that is a problem that would have to be solved by ASDF.
<shka_>
schweers: honestly, i don't think i can complain about sbcl compilation speed
<schweers>
it wasn’t meant to be a complaint. on the contrary
<shka_>
it is not super fast, sure, but it is not that slow either
<shka_>
it is just acceptable
<schweers>
I’d even continue using it if it were much slower
kdas_ has joined #lisp
<dim>
schweers: I think most people attributes slowness to being “interpreted” languages and don't understand that a language isn't compiled or interpreted, the implementation is, and may be both (as in javascript), and also that the level of flexibility and dynamism we have in CL, people think it must cost a lot in perfs
<schweers>
dim: I was just talking about how long it takes to compile a program
kushal has quit [Ping timeout: 250 seconds]
<no-defun-allowed>
if sbcl is a slow compiler, ccl sounds fun.
<aeth>
dim: It *does* costs a lot, it's just that on 2018 hardware those costs are usually laughable.
<loke>
no-defun-allowed: CCL's code generation isn't as good as SBCL's but I've never really been in a situation where that matters.
<shka_>
aeth: lol, nope
<schweers>
loke: it matters for me
<shka_>
aeth: lisp programs are fairly compact on RAM nowdays
<shka_>
especially if you copmare with so called scripting languages like python
<dim>
CCL/SBCL: pgloader shows the difference quite clearly, CCL is far better at Garbage Collection and memory maintenance while SBCL produces code that can be twice as fast
<schweers>
the programs maybe, but it seems that the runtime is still often too large for “embedded” devices. Which is why I don’t like said devices
<aeth>
shka_: Only because programs are using a lot more RAM than they used to. I am running several daemons that have almost bloated to the starting RAM usage of SBCL (including systemd and Xorg, which probably surprises no one)
<aeth>
But most SBCL programs don't compare to the web browser and browser-based 'native' programs
<shka_>
exactly
<shka_>
i could imagine someone saying that lisp programs are resource hogs 10 years ago
<shka_>
but nowdays they are very compact
<varjag>
yeah not in the era of electron
<shka_>
and it is not because lisp programs changed in nature
<schweers>
ah, speaking of garbage collection; does anyone know for sure what SBCL uses on AMD64? The manual is not exactly clear on the distinction between 32 and 64 bit x86.
<shka_>
it is just because everything else became bloated to the extreme
<schweers>
at least it wasn’t the last time I checked
<shka_>
schweers: same as 32 bit
lnostdal has joined #lisp
<schweers>
so it does not use a “state of the art” collector?
<shka_>
gengcc?
<shka_>
nope
kdas_ is now known as kushal
<aeth>
The state of the art for garbage collectors are made for Java and/or the JVM, in general.
<schweers>
wow. Now I’m even more impressed with GC. TIME in SBCL reports how much time was spent in GC and out of GC. I was always impressed by how little time the collector needed. Now that you’re telling me this could be even better, I’m even more impressed and convinced that GC is good for performance.
<shka_>
schweers: at least that's what i am getting from reading sbcl source code
<aeth>
schweers: The lowest hanging fruits in SBCL performance improvements are probably the GC and CLOS, at least based on stuff people say in #lisp
<aeth>
SBCL's CLOS implementation is apparently not even the fastest CLOS implementation
<schweers>
hmm. SB-EXT:GENERATION-MINIMUM-AGE-BEFORE-GC is a valid function on AMD64
<schweers>
which is available on gengc platforms only
<shka_>
sbcl folks are working hard on improving and maintaining it
<shka_>
schweers: perhaps i was wrong...
<varjag>
gencgc seems to be compiled in on x86-64 platforms, according to the runtime configs
random-nick has joined #lisp
shrdlu68 has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
_whitelogger has joined #lisp
schjetne has quit [Ping timeout: 272 seconds]
malm has quit [Ping timeout: 248 seconds]
kdas_ has joined #lisp
kushal has quit [Ping timeout: 250 seconds]
malm has joined #lisp
Colleen has quit [Ping timeout: 248 seconds]
Colleen has joined #lisp
Fare has joined #lisp
milanj has joined #lisp
Fare has quit [Ping timeout: 260 seconds]
easye has quit [Remote host closed the connection]
easye has joined #lisp
marvin3 has joined #lisp
mbrock_ has quit [Quit: Connection closed for inactivity]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
ebzzry has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
nowhere_man has quit [Ping timeout: 240 seconds]
zfree has joined #lisp
rozenglass has joined #lisp
``Erik has quit [Quit: leaving]
kdas_ is now known as kushal
orivej has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
acolarh has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
dddddd has joined #lisp
nowhere_man has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
charh has quit [Ping timeout: 276 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
steiner has quit [Remote host closed the connection]
ebzzry has joined #lisp
<LdBeth>
good evening
<shka_>
LdBeth: good evening to you
rozenglass has quit [Ping timeout: 256 seconds]
steiner has joined #lisp
<LdBeth>
is there *fast* approch to implement binary op so add #xFFFF and #x0123 is #x0122 and subtruact #x0123 form #x0121is #xFFFE
Bike has joined #lisp
<shka_>
LdBeth: mostly implementation specific
<shka_>
for instance, on sbcl i like to use ldb
<shka_>
somehow sbcl seems to be able to infer that this operation is allowed to overflow and produces slightly different code
steiner has quit [Remote host closed the connection]
<shka_>
LdBeth: try checking dissasemble of this function
SaganMan has quit [Quit: WeeChat 1.6]
<LdBeth>
ok
charh has joined #lisp
<shka_>
LdBeth: does it help?
charh has quit [Ping timeout: 256 seconds]
<LdBeth>
sure, thank you shka_
<shka_>
you are welcome, and awesome
Guest5800_ has joined #lisp
dvdmuckle has quit [Quit: Bouncer Surgery]
dvdmuckle has joined #lisp
steiner has quit [Remote host closed the connection]
dingusman has joined #lisp
acolarh has joined #lisp
<dingusman>
anyone have experience running hunchentoot servers as systemd services?
<Shinmera>
What's up
steiner has joined #lisp
<dingusman>
looking for a couple pieces of advice:
<dingusman>
any way to run the repl as a service without wrapping it in screen?
<dingusman>
how can I get server logs to journald?
<dingusman>
those are the big ones
<Shinmera>
well you won't get access to the repl if you run it under systemd
<Shinmera>
but the good news is you don't need to, just spawn a swank server and connect to it with slime (tunnelling the port through ssh for instance)
<Shinmera>
systemd will automatically log any stderr/stdout output to journald for all its services, so you don't need to do anything for that
housel has quit [Ping timeout: 244 seconds]
<dingusman>
ok, yeah, if I didn't run screen I guess the second question is no longer relevant
<dingusman>
I'm already running a swank server + connecting with ssh tunnelling
<dingusman>
How can I do that without running the repl though?
<dingusman>
dim: thank you, that's helpful. I've been looking for some real-life hunchentoot server code. There's a lot for me to learn in there
heisig has quit [Quit: Leaving]
<Shinmera>
Reminds me that I should write a tutorial/guide on running Radiance in production
<Shinmera>
So much to do!
<dim>
dingusman: the part I like a lot is the serving of static files from memory, and building a binary image that includes those static resources, so that you only have one file to deploy
<dingusman>
That is neat. I'm doing something pretty similar. Generate a ql dependency bundle, html/js with who/parenscript, then load it all in and dump it to a core image to deploy
fikka has joined #lisp
<dingusman>
The really amazing part to me is the instant startup time
<dim>
hehe... do you compress the core? it might make the startup time a little longer, but gives a much smaller image
<dingusman>
No, I haven't tried that yet
fikka has quit [Ping timeout: 240 seconds]
dingusman has quit [Ping timeout: 240 seconds]
dingusman has joined #lisp
dale has joined #lisp
<dingusman>
dim: managed to kill my emacs in the process, but compression makes a big difference
<dingusman>
75M to 15M in my case
<dingusman>
and no noticeable difference in startup time
<Shinmera>
there's a noticeable difference if you want to do scripts and stuff but for a heavy-weight thing like a server or a gui it's perfectly fine.
Inline has joined #lisp
<Shinmera>
even loading from FASLs can be acceptable.
fikka has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
FreeBirdLjj has joined #lisp
Cymew has quit [Ping timeout: 276 seconds]
<ebrasca>
Hi
schweers has quit [Ping timeout: 276 seconds]
edgar-rft has quit [Remote host closed the connection]
rippa has joined #lisp
cage_ has joined #lisp
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
housel has joined #lisp
orivej has joined #lisp
shifty has quit [Remote host closed the connection]
shifty has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shka_ has quit [Quit: WeeChat 1.9.1]
Bronsa has joined #lisp
robotoad has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
atgreen_ has joined #lisp
robotoad_ has joined #lisp
renzhi_ has joined #lisp
cage_ has quit [Read error: Connection reset by peer]
atgreen has quit [Remote host closed the connection]
robotoad has quit [Read error: Connection reset by peer]
emacsoma` has quit [Remote host closed the connection]
steiner has quit [Remote host closed the connection]
renzhi has quit [Ping timeout: 256 seconds]
SaganMan has joined #lisp
fikka has joined #lisp
<ebrasca>
beach: Have you think about contributing in mezzano?
dingusman has quit [Ping timeout: 244 seconds]
Fare has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
fikka has quit [Ping timeout: 240 seconds]
mindCrime has joined #lisp
gigetoo has quit [Ping timeout: 268 seconds]
emaczen has joined #lisp
pjb has joined #lisp
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
zotan has quit [Ping timeout: 256 seconds]
Ober has quit [Quit: Emacs must have died]
Kevslinger has joined #lisp
housel has quit [Remote host closed the connection]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
light2yellow has joined #lisp
Demosthenex has quit [Ping timeout: 248 seconds]
housel has joined #lisp
Demosthenex has joined #lisp
fikka has joined #lisp
Zhivago has quit [Ping timeout: 256 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
thijso has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 276 seconds]
shka_ has joined #lisp
<shka_>
good evening
<Demosthenex>
evening!
SaganMan has quit [Quit: WeeChat 1.6]
Bronsa has quit [Ping timeout: 244 seconds]
thawes has joined #lisp
light2yellow has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
light2yellow has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
makomo has quit [Read error: Connection reset by peer]
sz0 has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
charh has joined #lisp
charh has quit [Client Quit]
light2yellow has quit [Read error: Connection reset by peer]
Fare has quit [Ping timeout: 276 seconds]
Denommus has joined #lisp
nowhere_man has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
makomo has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
edgar-rft has joined #lisp
jkordani_ has joined #lisp
Fare has joined #lisp
fikka has joined #lisp
jkordani has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 260 seconds]
Fare has quit [Ping timeout: 276 seconds]
makomo has quit [Quit: WeeChat 2.2]
charh has joined #lisp
fikka has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 244 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
loli has quit [Quit: WeeChat 2.2]
loli has joined #lisp
meepdeew has joined #lisp
meepdeew has quit [Ping timeout: 240 seconds]
Demosthenex has quit [Ping timeout: 240 seconds]
sauvin has quit [Remote host closed the connection]
light2yellow has joined #lisp
lisper29 has joined #lisp
Jesin has quit [Quit: Leaving]
stylewarning has quit [*.net *.split]
gko has quit [*.net *.split]
ircbrowse has quit [*.net *.split]
voidlily has quit [*.net *.split]
lieven has quit [*.net *.split]
gz has quit [*.net *.split]
antoszka has quit [*.net *.split]
pchrist has quit [*.net *.split]
Myon has quit [*.net *.split]
umpc has quit [*.net *.split]
gingerale has quit [*.net *.split]
z0d has quit [*.net *.split]
jurov has quit [*.net *.split]
gko has joined #lisp
pchrist_ has joined #lisp
jurov has joined #lisp
ircbrowse has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
voidlily has joined #lisp
l1x has quit [*.net *.split]
shenghi has quit [*.net *.split]
les has quit [*.net *.split]
sigjuice has quit [*.net *.split]
rann has quit [*.net *.split]
gsl has quit [*.net *.split]
trig-ger_ has quit [*.net *.split]
bheesham has quit [*.net *.split]
z0d has joined #lisp
les has joined #lisp
pierpal has quit [Quit: Poof]
sigjuice has joined #lisp
pierpal has joined #lisp
umpc has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
Xof has quit [Ping timeout: 268 seconds]
|3b| has quit [Remote host closed the connection]
|3b| has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<jackdaniel>
hey. I want to write a fast function which does alpha-composition between two rgba pixels, here's what I've got: http://ix.io/1kSL/lisp
<jackdaniel>
I'm not very good with bit fiddling so I'd appreciate any hints how I could improve this code
<jackdaniel>
(whole functions works on two arrays of course)
jkordani has joined #lisp
Jesin has joined #lisp
fikka has joined #lisp
jkordani_ has quit [Ping timeout: 240 seconds]
gigetoo has joined #lisp
NB0X-Matt-CA has joined #lisp
Fare has joined #lisp
stylewarning has joined #lisp
random-nick has joined #lisp
Jesin has quit [Quit: Leaving]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<fe[nl]ix>
lisper29: that would be me
dented42 has joined #lisp
X-Scale has quit [Ping timeout: 256 seconds]
[X-Scale] has joined #lisp
pierpa has joined #lisp
Jesin has joined #lisp
[X-Scale] is now known as X-Scale
light2yellow has quit [Quit: WeeChat 2.2]
Jachy has quit [*.net *.split]
creat has quit [*.net *.split]
johs has quit [*.net *.split]
ecraven has quit [*.net *.split]
SlashLife has quit [*.net *.split]
ecraven has joined #lisp
SlashLife has joined #lisp
warweasle has quit [Quit: later]
creat has joined #lisp
<_death>
jackdaniel: look-up tables would be an easy way, though not the fastest
pacon has quit [*.net *.split]
n3t has quit [*.net *.split]
djh_ has quit [*.net *.split]
uint has quit [*.net *.split]
zymurgy has quit [*.net *.split]
trn has quit [*.net *.split]
runejuhl has quit [*.net *.split]
sakalli_ has quit [*.net *.split]
bhyde has quit [*.net *.split]
sukaeto has quit [*.net *.split]
mikaelj has quit [*.net *.split]
joga has quit [*.net *.split]
<jackdaniel>
_death: thanks. it is internal function because I care about speed in there (it is for McCLIM framebuffer image rendering)
milanj has joined #lisp
<jackdaniel>
I'll look up the look-up tables though, may be useful for testing if I didn't mess things up
trn has joined #lisp
lumm has quit [Ping timeout: 256 seconds]
rvirding has quit [Ping timeout: 256 seconds]
PyroLagus has quit [Ping timeout: 256 seconds]
lumm has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
<Shinmera>
You could use (list 'gethash ,keyword ,sym) or, as I pointed out above, `(gethash ,',keyword ,',sym)
<Shinmera>
mm, *(list 'gethash ',keyword ',sym)
<fouric>
neither of those work unfortunately - should i just give up on quasiquote and use LIST etc. instead?
<fouric>
that is, am i trying to do something that fundamentally cannot be done with quasiquote
<Shinmera>
It can be done and I told you how. Maybe you're asking the wrong question, and besides that your function looks really weird. How do you hope to gethash from a variable that you just gensym up?
<aeth>
ebrasca: If you want money for Mezzano I'd recommend refocusing the project to be a cloud OS for deploying Lisp applications. e.g. https://en.wikipedia.org/wiki/Unikernel
<fouric>
you're right, it does work fine
<fouric>
totally my b
angavrilov has quit [Remote host closed the connection]
<fouric>
i left some stuff around in the REPL i was testing it with
lumm has joined #lisp
<Josh_2>
hey so neither slime or sly are connecting to the sbcl backend, although sbcl is launching in another buffer on my Emacs
<fouric>
ty Shinmera
<Shinmera>
sure
<fouric>
much appreciated
<Josh_2>
Getting this error (("Error in timer" sly-attempt-connection (#<process inferior-lisp> nil 3) (void-function set-up-sly-ac)))
<aeth>
ebrasca: e.g. get a server Mezzano running on a cloud provider and you just virtualize your Lisp server application on Mezzano.
<fouric>
ebrasca: do you have a bountysource thing set up or something?
lumm_ has joined #lisp
<ebrasca>
fouric: I am contributor to mezzano. I don't think there is bountysource or sometink like this.
<ebrasca>
aeth: Mezzano can run on qemu , kvm and have single address space.
lumm has quit [Read error: Connection reset by peer]
lumm_ is now known as lumm
charh has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
Good morning everyone!
<ebrasca>
aeth: Today I have fix problems with tcp ip in mezzano.
<aeth>
ebrasca: Does it run in a non-graphical mode?
<aeth>
ebrasca: And does it support SSH?
charh has joined #lisp
<aeth>
ebrasca: I would go the Ubuntu route and have a Server version and a Desktop version. In fact, Ubuntu also has a Cloud edition, which is probably a modified Server edition that's tested on various cloud providers.
<ebrasca>
aeth: I can connect to it with slime.
<ebrasca>
aeth: froggey say it is relativeli easy to make it non-graphical.
meepdeew has joined #lisp
<aeth>
ebrasca: You'd probably want to tunnel SLIME over SSH or something else that's encrypted.
<aeth>
ebrasca: If I were you I'd put together a list of proposed server/cloud features and see if anyone is interested in Mezzano as a server.
* fouric
raises hand
<ebrasca>
fouric: Do you have someting in mind?
mindCrime has quit [Ping timeout: 260 seconds]
<ebrasca>
aeth: I can make this list.
<ebrasca>
aeth: How to find interested people in Mezzano as a server?
<aeth>
ebrasca: Make a blog post about Mezzano-as-a-server and see if it gets featured on Hacker News, /r/programming, comp.lang.lisp, etc.
<aeth>
You probably need two lists. What it does now and what it should do in the future.
<aeth>
You should probably have someone proofread a draft here first.
<aeth>
You should also try to get it running on a cloud platform if there are cloud platforms that let non-Linux OSes run on them. You'll need to have an encrypted way to connect to it first, though.
<aeth>
If it can run a CL web server you'd probably want to put the Mezzano web server behind another server that runs a mature web server like nginx. I'm not a cloud person, though, so I'm not sure how that works.
<ebrasca>
Mezzano have tcp/ip wichout retransmission.
<ebrasca>
It can read and write to fat32 (Probably not optimized).
asarch has joined #lisp
Bike has quit [Ping timeout: 252 seconds]
<ebrasca>
aeth: Do you mean someting like tcp with retransmission , ssh and hunchentoot ?
<aeth>
ebrasca: yes
<aeth>
ebrasca: If there's any money in Mezzano it's in servers and cloud. No one (or close enough to no one) is going to switch their client from Windows or Android.
<aeth>
But servers can run anything.
<aeth>
I would personally focus on the network stack and remote access for now. Linux was a stable server OS long before it was a stable desktop one.
rozenglass has joined #lisp
<ebrasca>
aeth: Yea I am alredy focus in tcp/ip.
dented42 has joined #lisp
<aeth>
Don't forget UDP.
<aeth>
Almost everything is either TCP or UDP afaik.
<ebrasca>
I have done some ARP.
dented42 has quit [Client Quit]
dale has quit [Quit: dale]
random-nick has quit [Read error: Connection reset by peer]
<aeth>
ebrasca: I think the time to post about this is when you have a working proof of concept of Mezzano running as a server.
<aeth>
That's all but guaranteed to make it to the front of Hacker News and /r/lisp and has a decent chance of making it to /r/programming. Your pitch for donations or bug/feature bounties or Mezzano-as-a-service or whatever can go at the bottom of the post.
<aeth>
(If a web server is too hard you can think of something simpler. You're already almost there by having SLIME run.)
Denommus has quit [Remote host closed the connection]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
rocx has joined #lisp
quazimodo has joined #lisp
dented42 has joined #lisp
moei has joined #lisp
<White_Flame>
ebrasca: and you should set up the means for accepting donations (paypal button, patreon, etc) before such an announcement.
lavaflow has joined #lisp
lumm_ has joined #lisp
Bike has joined #lisp
lumm has quit [Ping timeout: 264 seconds]
lumm_ is now known as lumm
rumbler31 has quit [Remote host closed the connection]
Guest5800_ has quit [Quit: Connection closed for inactivity]
emaczen has quit [Read error: Connection reset by peer]
emaczen has joined #lisp
rumbler31 has joined #lisp
jkordani_ has joined #lisp
jkordani has quit [Ping timeout: 252 seconds]
rumbler31 has quit [Remote host closed the connection]
robotoad_ has quit [Quit: robotoad_]
parjanya has quit [Remote host closed the connection]