<HiRE>
I was kind of curious how they would solve pointers and what-not
<HiRE>
because at least as far as my lisp experience has gone, there's no easy way to address unsafe memory in lisp.
<_death>
you could just allocate a huge (sparse?) array and represent pointers as indices to it
<HiRE>
that makes sense since you'd be relying on the backing of lisp anyway. One thing the usenet post mentioned was zeta C cut a few corners like implementing ints and longs as lisp numbers so bignums existed magically without any extra work
<HiRE>
which is _really_ cool but also not standard C
<HiRE>
After reading that paper on a lisp operating system I got to thinking about how you'd implement all the little things. One of the things on my list would be a decent C compiler since a ton of good software is in C and rewriting it would be a nightmare.
<oni-on-ion>
delicious C with numeric tower and macros and repl. with ECL its potentially easier to CL->C
<oni-on-ion>
oh
<oni-on-ion>
i think that kernel drivers might be more of a nightmare
<_death>
HiRE: well, the cliki entry also mentions vacietis, which should work (sans bitrot?)
<oni-on-ion>
CL is immune to bitrot =P
<HiRE>
yeah I thought that kernel drivers and process management would be dissertation worthy exercises
<_death>
ah yes, it's in quicklisp, so likely works
<HiRE>
bootstrapping it might require C?
<HiRE>
or at least some ASM I would guess.
<_death>
hmm, or maybe not
<Bike>
sometimes when people talk about lisp operating systems they mean something managed, so you couldn't just run random C code
<Bike>
this is the case for SICL for example
<Bike>
(i'm pretty sure, at least)
<HiRE>
What would a managed operating system entail? I figured the OS would have a baseline requirement of ring 0
<HiRE>
unless I guess you wrote a small bootstrap kernel VM and ran the thing on top of it...
<_death>
ok, this works (let ((*readtable* vacietis:c-readtable) (vacietis:*compiler-state* (vacietis:make-compiler-state))) (read-from-string "int foo(int x, int y) { return x + y; }"))
<Bike>
well, i mean, in that some of the safety is due to the compiler rather than the runtime
bendersteed has quit [Read error: Connection reset by peer]
<aeth>
An alternate approach you could use for a C compiler is to use CFFI data structures as your compilation target, if that's complete enough.
<aeth>
It would be just as unsafe as C, of course, and it would be slower than C because of the overhead of CFFI
<oni-on-ion>
aha
<HiRE>
ah yeah, since its a thought experiment I didnt consider safety
<HiRE>
just the question of how it'd be done
<HiRE>
oh interesting singularity works how I supposed above
<HiRE>
a small bootstrapped client has some stuff that then runs the kernel in a management environment
<HiRE>
thats really cool
<HiRE>
I wonder what kind of overhead you'd have with ring 0 garbage collection
<Bike>
that's kind of different. i mean there's no reason a lisp machine has to use a vm at all
<no-defun-allowed>
Not much.
<froggey>
Iota uses the "giant ub8 vector" approach for pointers. nothing weird or unsafe required
<no-defun-allowed>
If everything uses the same memory space, then you can "reuse" objects, so there would be less to collect.
<no-defun-allowed>
And, of course, you can set up the memory management unit however you want, so it could be somewhat more efficient than in a process.
<HiRE>
well yeah I'd suppose not. Symbolics stuff never used a VM but it did use specialized hardware. So eventually your abstraction would have to crack somewhere and you'd have to touch ASM or C I would guess.
<HiRE>
perhaps at the kernel device driver level
<no-defun-allowed>
Also of course, any overhead saved by not having garbage collection is probably reintroduced by having to copy data needlessly and programmers getting confused about who frees what.
<Bike>
probably just assembly
<HiRE>
my wonder with ring 0 GC was if you had something like stop the world garbage collection your entire OS could in theory grind to a halt for a short time
space_otter has quit [Remote host closed the connection]
<no-defun-allowed>
Don't use a STW collector then.
<buffergn0me>
Vacietis should be portable Common Lisp (if not, it is a bug)
<no-defun-allowed>
Lisp machines had that problem, then reduced it significantly using incremental collection, and then generational collection.
<froggey>
assembly is only really needed for dealing with really weird parts of the machine and most of the time you can get away with thin wrappers around whatever feature is causing trouble
<froggey>
and for drivers the only primitives you need are some way to access memory & deal with interrupts
<froggey>
no C required anywhere
<no-defun-allowed>
Yeah, you would just want to be able to call into Lisp from an interrupt and a few primitives for accessing memory and...were they ports in x86? x86 also has a "port" address space from memory.
<buffergn0me>
Also Vacietis can already generate stand-alone executables in the manner no-defun-allowed mentioned
GuerrillaMonkey has joined #lisp
<no-defun-allowed>
I think those are ports.
<HiRE>
yah I think the term was ports
<froggey>
yeah. x86 has IO ports, accessed with special instructions ("in" and "out")
Jeanne-Kamikaze has quit [Ping timeout: 260 seconds]
<_death>
no-defun-allowed: there are IN and OUT instructions for ports
<no-defun-allowed>
Yup.
<buffergn0me>
It should be possible to hack up a wrapper for ECL's c:build-static-library to make libraries
markong has joined #lisp
<no-defun-allowed>
Contrast to 68k and friends, which only have memory mapped devices, and should have been the predominant architecture...grumble grumble.
<buffergn0me>
wrt to drivers, the reason I wrote Vacieties was to enable no-change use of OpenBSD drivers in a future Lisp operating system (this was before Mezzano, or at least before I had heard of it, and after Movitz was abandoned)
markoong has quit [Ping timeout: 255 seconds]
markoong has joined #lisp
<buffergn0me>
NetBSD came up with very nice portable APIs for device drivers that OpenBSD largely adapted (OpenBSD has more drivers)
<buffergn0me>
Although NetBSD has RUMP which is basically this use case and should make things easier
<buffergn0me>
Also in retrospect I realized that Vacietis should be useful for generating FFI glue code from header files, although no one has done that yet
markong has quit [Ping timeout: 256 seconds]
Lord_Nightmare has joined #lisp
igemnace has quit [Remote host closed the connection]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 272 seconds]
EvW has quit [Read error: Connection reset by peer]
EvW has joined #lisp
markong has joined #lisp
EvW has quit [Read error: Connection reset by peer]
EvW has joined #lisp
markoong has quit [Ping timeout: 265 seconds]
Involuntary has joined #lisp
GuerrillaMonkey has quit [Ping timeout: 240 seconds]
<p_l>
no-defun-allowed: port io is easier to implement in hw
Involuntary has quit [Quit: Leaving]
Jeanne-Kamikaze has joined #lisp
prince1 has joined #lisp
prince1 has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
In the processor or in the external logic? There would be decoding either way.
EvW has quit [Ping timeout: 240 seconds]
<HiRE>
hah I wrote a toy OS with a stupid command line a long time ago. A lisp OS is way outside my pay grade. My current paygrade is "can implement a stack and queue using CLOS"
<HiRE>
being a professional developer, I've realized its incredibly hard to spin up quickly to a language using your own ingenuity lol
<HiRE>
suppose I should just enjoy the journe
<HiRE>
y
<no-defun-allowed>
Hm, maybe it involves less decoding with an IO port pin. My reading of some PCI clients suggests that you end up using memory mapped IO for fast things like storage.
<oni-on-ion>
it is the Lisp Curse
<no-defun-allowed>
What?
<oni-on-ion>
"Lisp is so powerful that problems which are technical issues in other programming languages are social issues in Lisp"
<no-defun-allowed>
Oh, that.
<oni-on-ion>
needs people, a sangha of hackers =)
<no-defun-allowed>
That is a conspiracy made by the webshit companies to sell more web page---wait, no I'm supposed to be serious. No, but the author of that had little reason to comment on Lisp, and it's not as if it doesn't exist with other languages.
<HiRE>
its just a great language because it doesnt try to be anything
<HiRE>
I am really tired of the current trend of benevolent dictators for life
<no-defun-allowed>
You just have more that can be argued over, with macros, metaprogramming et al; but of course, you also get to have those features on the flip side.
<no-defun-allowed>
HiRE: Definitely.
<HiRE>
I consult professionally. Clients often _tell_ me what languages they want.
<HiRE>
usually its <bleeding_edge_tech> just 'cus
<HiRE>
im left asking why more often I than I prefer.
<HiRE>
Not that I'd force lisp on these people...but you have to wonder why a big company would prefer a walled garden over something more flexible.
<oni-on-ion>
what i get from that quote/curse, is that lisp programming is a social adventure. in reference to HiRE 's mention of "using one's own ingenuity"
<no-defun-allowed>
If you have enough slack in who you can work with, I would try not to give them an option.
<HiRE>
sometimes I get that option. However beach made a great point in don't write a check your butt cant cash. I can evangelize lisp but when things break I may not be able to fix it...yet
<no-defun-allowed>
Are your clients also programmers?
zaquest has joined #lisp
<no-defun-allowed>
You don't have to evangelize anything if they're not.
<HiRE>
yeah, I deal exclusively with tech companies.
<HiRE>
Unfortunately cracking the juicy government/state contract nut is a lot harder than it looks.
<no-defun-allowed>
Hm. If they have requirements, and you have requirements, and they don't fit, maybe you should find other clients.
<HiRE>
Well, I was thinking I might be able to push something like racket or clojure that is flavored like modern tech but lispy at its core.
<HiRE>
There's a lot of "if it's not used by FAANG+ its not good enough for us"
<HiRE>
sometimes you have to take work to eat...lol
<HiRE>
clojure was my current idea as a selling point because of interop with the JVM
<HiRE>
good intro to lisp for a client without much risk to their infra
<oni-on-ion>
hmm what's the "N"?
<HiRE>
I think it's supposed to be netflix
<oni-on-ion>
ahh
<no-defun-allowed>
What's the other letters? Facebook, Apple, another A...Google?
<oni-on-ion>
i wonder if that was an afterthought, considering the word without the N
<HiRE>
facebook apple amazon netfix google (+ everything-like-them)
<oni-on-ion>
amazon
<oni-on-ion>
ah nuts i had the two A's backwards. =)
<no-defun-allowed>
I dunno, are any clients even close to that scale? If not, I would just say that you probably have different techniques.
<HiRE>
hah, thats the funny part
<HiRE>
no not at all
<HiRE>
For example, I had a long engagement with a client who used golang for everything despite it being arguably the worst choice for everything.
<HiRE>
If you couldn't guess, their CTO was an ex-googler.
<HiRE>
small company, maybe 50MM rev and 100 employees.
<HiRE>
this is where my clojure play came in to my mind
<HiRE>
lots of them have ancient JVM backends
<HiRE>
no one wants to touch it, and its mostly managed by greybeards.
<oni-on-ion>
clojurescript uses google tools (one called, ironically, closure)
<no-defun-allowed>
One analogy I hear is that building a dog house is trivial, but building a larger building much less so; it's not like you can just scale it up by a factor of N.
<HiRE>
I did get one client to use cljs a while ago when clojure was a hot commodity.
<HiRE>
Thats where my interest in lisps really spurred.
<oni-on-ion>
also there is ABCL, no-defun-allowed 's favorite implementation
<HiRE>
Whats the difference between ABCL and SBCL? I use sbcl
<no-defun-allowed>
The reverse also works; your dog house doesn't need much in terms of stabilisation.
<no-defun-allowed>
ABCL runs on the JVM and is called "Armed Bear Common Lisp".
<HiRE>
oh thats incredible. I didnt know that. Sell me on it
<no-defun-allowed>
SBCL runs without a virtual machine and is called "Steel Banks Common Lisp".
<HiRE>
I know clojure so how would you compare abcl to clojure?
<oni-on-ion>
one bank
buffergn0me has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
From a philosophical POV, ABCL is still Lisp that happens to run on a JVM. Clojure is "Lisp" in Java.
<oni-on-ion>
abcl is the same lisp as sbcl -- clojure is its own thing
<no-defun-allowed>
Also, only the former is on topic :)
space_otter has joined #lisp
<HiRE>
oh ok, I see. I won't talk about clojure then :)
<no-defun-allowed>
By that, I mean ABCL implements just about all of ANSI Common Lisp on the JVM, diverging from Java, most notably in the object and condition systems and numeric tower in my opinion.
<HiRE>
so ABCL is a common lisp
<HiRE>
but on the JVM
<no-defun-allowed>
Thanks. I'm allergic to coffee.
<HiRE>
im sorry it must be tough being a developer :P
<no-defun-allowed>
Yes, ABCL is an implementation of Common Lisp on the Java virtual machine.
<HiRE>
thats a pretty slick idea tbh. As long as it compiles down to class files and jars there's zero risk to introducing it into a system
<oni-on-ion>
eww @ coffeescript. yay @ cappuccino (and objective-j)
<HiRE>
(coffeescript gives me PTSD)
<no-defun-allowed>
I don't program for money yet, and the Java I do know from university is just procedural code with "public class FileName { public static void main(String[] args) { ... } }" around it.
<HiRE>
Professionally speaking everything java project I've contracted with from about 2014 on was a mix of languages
Involuntary has joined #lisp
<HiRE>
the JVM is a very powerful uniting force in development
<HiRE>
its very cool a common lisp runs on it
wxie has quit [Quit: wxie]
<HiRE>
by mix of languages I mean it was vanilla java, scala, some clojure, <obscure language that compiles to java bytecode>
<HiRE>
it didn't really matter as long as someone was maintaining it and it compiled.
<HiRE>
ABCL would be a VERY easy sell for me.
<no-defun-allowed>
The other main difference is that the FFI looks less normal. You write something like (java:jcall "methodName" subject arguments...) instead of (.methodName subject arguments), which is also much less funny.
<HiRE>
I feel like (java:jcall ...) seems better anyway
<HiRE>
(.instanceName args) feels super...weird
<HiRE>
methodName*
<no-defun-allowed>
I think the ABCL contrib package has a little reader macro that makes (#"methodName" subject arguments ...) work though.
<HiRE>
I guess that also jives with multiple dispatch sorta
<HiRE>
SORTA
Jeanne-Kamikaze has quit [Ping timeout: 265 seconds]
<HiRE>
in the sense you get the same form (func-name (matcher match) args) kind of thing
<no-defun-allowed>
oni-on-ion thinks ABCL is my favourite implementation because I've wrote substantially about getting ABCL to talk to Minecraft, for which I had to hack up some custom funcallable-instances to make deobsfucation and the interface feel right.
<HiRE>
I have no real preference. I use SBCL mostly because it seems fast and can compile to native code.
<HiRE>
which is a really weak reason to like it.
<no-defun-allowed>
That is very unnecessary unless you have to handle your own obfuscation, but making a package with wrapper functions so you can write (java-module:get-foo foo-having-thing) is cute.
<HiRE>
I also use SBCL because lispworks is expensive even if I use my student ID.
<no-defun-allowed>
Sure. Clozure Common Lisp and ECL both compile to machine code (the latter with C as an intermediate step), so you have other options for free/libre native-code implementations.
<no-defun-allowed>
The former has a compiler that does less optimisations, which is good if you're compiling a lot of code (which you rarely will), and subjectively nicer source code.
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<HiRE>
I strangely like the idea of compiling to C as an intermediary step
<HiRE>
because you can leverage the decades of optimization in GCC/clang
<oni-on-ion>
plus emscripten =P
<no-defun-allowed>
I don't think it works well in practice. aeth would say something like, "C compilers optimize C idioms well, generating C rarely creates code that uses said idioms".
rumbler31 has quit [Remote host closed the connection]
<aeth>
Right.
<aeth>
Even hardcore C/C++ fans will generally recommend LLVM IR instead of directly targeting C these days, except even that has issues. Clasp does this and has encountered quite a few problems that other CL implementations don't have to deal with, such as slow conditions (the CL equivalent of exceptions/errors)
lavaflow has quit [Ping timeout: 256 seconds]
<aeth>
C compilers are written for C/C++ semantics (usually they at the very least handle both languages these days)
<aeth>
Things that the C/C++ world doesn't think about but that can be done efficiently in ASM include multiple return values, which CL has.
<aeth>
That being said, ECL does compile to C and Clasp does compile to LLVM IR, so both approaches are used, they're just slower in practice than SBCL. There should probably be an FAQ, that includes this point.
prince1 has joined #lisp
wxie has joined #lisp
lavaflow has joined #lisp
prince1 has quit [Ping timeout: 265 seconds]
<HiRE>
no-defun-allowed, thats a good point
<HiRE>
if you dont program to C idioms, the optimizer may not optimize right.
<HiRE>
also makes sense aeth
orivej has quit [Ping timeout: 255 seconds]
wxie has quit [Quit: wxie]
wxie has joined #lisp
davepdotorg has joined #lisp
<beach>
Good morning everyone!
karlosz has quit [Quit: karlosz]
libertyprime has joined #lisp
davepdotorg has quit [Ping timeout: 268 seconds]
<aeth>
good morning beach
wxie has quit [Ping timeout: 240 seconds]
gravicappa has joined #lisp
moon-child is now known as AlexaBot
AlexaBot is now known as moon-child
libertyprime has quit [Quit: Lost terminal]
Bike has quit [Quit: leaving]
tourjin has joined #lisp
wxie has joined #lisp
tourjin has quit [Client Quit]
<p_l>
no-defun-allowed: port io is simple on the external logic and on implementing channel DMA
<p_l>
no-defun-allowed: decoding logic is also greatly simplified
<p_l>
works pretty similar to SPI if you made it 8/16 bit wide
<no-defun-allowed>
Right.
tourjin has joined #lisp
<p_l>
no-defun-allowed: also, it's very, very easy to make channel DMA capability with ISA port IO. no need to busmaster etc,
<tourjin>
how can I check if I have sb-grovel ?
Involuntary has quit [Quit: Leaving]
<equwal>
(in-package :sb-grovel)
<equwal>
(find-package :sb-grovell)
<equwal>
(find-package :sb-grovel)
dddddd has quit [Ping timeout: 240 seconds]
spacedbat has quit [Ping timeout: 252 seconds]
spacedbat has joined #lisp
<tourjin>
am I connected?
<beach>
Apparently, yes.
<tourjin>
ok how can I check If I have sb-grovel?
<beach>
equwal told you.
<tourjin>
oh.. I did'nt see that. thanks
prince1 has joined #lisp
_whitelogger has joined #lisp
ahungry has quit [Remote host closed the connection]
akoana has left #lisp ["Leaving"]
Nikotiini has quit [Ping timeout: 256 seconds]
karlosz has joined #lisp
<tourjin>
cl-user> prompt changes to sb-grovel> when I invoke (in-package :sb-grovel). is this normal? and if I type it in emacs slime I have #<package "sb-grovel"> but I type it from sbcl I get nil. why do I have different answer? and why my prompt changes ?
Nikotiini has joined #lisp
<no-defun-allowed>
Yep, totally normal.
gravicappa has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
The prompt does indeed take the name of the current package.
wxie has quit [Ping timeout: 256 seconds]
<tourjin>
i see.
<no-defun-allowed>
I cannot replicate "typing [the IN-PACKAGE form and getting] nil" though.
<White_Flame>
but yeah, find-package will tell you if it's present or not
<White_Flame>
something in SLIME is probably pulling it in, while the default cmdline startup doesn't
<no-defun-allowed>
LdBeth: Hard to say immediately. I think MIT LOOP generates the former for (LOOP .... COLLECT ...) though.
<no-defun-allowed>
However, I also heard the latter had more cache-friendly properties, but caches are above my paygrade.
<no-defun-allowed>
Some lousy testing suggests that RPLACD'ing the end of a list with new conses is about 10% faster than PUSHing then NREVERSE on SBCL.
<no-defun-allowed>
Same result on Clozure.
Telior has joined #lisp
varjag has joined #lisp
<no-defun-allowed>
Ah, that's why you said setcar.
<no-defun-allowed>
I don't know the performance characteristics of elisp.
<beach>
no-defun-allowed: I don't see the utterance by LdBeth that you are commenting on.
<no-defun-allowed>
"will construct a list from head to tail with a reference using setcar/setcdr more performant than simply calling push and nreverse?"
<beach>
OK, but where was it uttered?
<no-defun-allowed>
Here, about 10 minutes ago.
jeosol has joined #lisp
<beach>
Hmm.
<no-defun-allowed>
LdBeth: I think something between you, matrix, the IRC bridge and #lisp is broken.
<beach>
It didn't make it here and it didn't make it to the logs by Colleen either.
varjag has quit [Ping timeout: 260 seconds]
ldb has joined #lisp
<no-defun-allowed>
Strangely, I'm not surprised. The bridge operators and Freenode operators aren't on the best of terms, in my opinion which is formed from a brief discussion with a bridge operator, as the bridge has to open one connection per user. Then the bridge runs out of connections.
<no-defun-allowed>
LdBeth: I saw it, but the tymoon log didn't.
<ldb>
so I pumped up my irssi client
<no-defun-allowed>
It does appear you did.
<no-defun-allowed>
What you missed was: "will construct a list from head to tail with a reference using setcar/setcdr more performant than simply calling push and nreverse?" "with emacs's lisp byte-compiler I can only get the former close to the later but still slower, so I'd blame that emacs's byte code has some overhead" then some confusion about something dropping messages.
Telior has quit [Ping timeout: 240 seconds]
ebrasca has joined #lisp
torbo has quit [Remote host closed the connection]
vlatkoB has joined #lisp
ldb has quit [Ping timeout: 256 seconds]
<equwal>
I can't see LdBeth's messages, but he is in the names
dale has quit [Quit: My computer has gone to sleep]
_whitelogger has joined #lisp
_whitelogger has joined #lisp
rumbler31 has joined #lisp
heisig has joined #lisp
prince1 has joined #lisp
rumbler31 has quit [Ping timeout: 255 seconds]
gravicappa has joined #lisp
prince1 has quit [Ping timeout: 255 seconds]
Inline has joined #lisp
zaquest has quit [Quit: Leaving]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 272 seconds]
ldb has joined #lisp
heisig has quit [Quit: Leaving]
adam4567 has joined #lisp
ldb has quit [Ping timeout: 258 seconds]
heisig has joined #lisp
dmiles has quit []
space_otter has quit [Remote host closed the connection]
<Gnuxie[m]>
Yes the bridge is 1 connection per user
adam4567 has quit [Remote host closed the connection]
<no-defun-allowed>
Gnuxie 💜🐝: I can read your messages from Colleen's log, so...
<no-defun-allowed>
LdBeth: Congratulations! You are today's winner of the connection limit lottery! Your prize is that you don't get to write anything to IRC.
<equwal>
Does "the matrix" refer to matrix.org? And what does that have to do with the #lisp freenode irc?
<equwal>
I'm not clear on the details of this stuff. Can someone donate a bridge if they desire to so LdBeth can submit messages?
<aeth>
matrix does a bridge thing to IRC, and basically acts as a bouncer+client
<no-defun-allowed>
Yes, "Matrix" is matrix.org
<equwal>
So it is the mistake of LdBeth to use that service rather than just connecting to freenode...right?
<no-defun-allowed>
Someone decided the poor souls on it (myself, LdBeth included) needed to be able to communicate with non-Matrix groups, and wrote a bridge which relays messages between Matrix and IRC.
<jackdaniel>
whether it is mistake or not is a question which belongs somewhere else
<jackdaniel>
let's just settle on a fact, that some messages does not arrive from that network
<equwal>
Can I run this bridge on my debian server? I can understand the desire to avoid setting up one's own bouncer -- it is a huge pain.
<no-defun-allowed>
As every user must have a separate connection to the network, and I believe there is only one bridge server, the operator probably has hit a connection limit.
<equwal>
But I'd rather setup my own bouncer than not be able to send messages, LOL.
rumbler31 has joined #lisp
<no-defun-allowed>
equwal: Do you want to use IRC from Matrix? It's a bouncer that converts protocols, so you would probably be better served with IRC-only software.
<jackdaniel>
equwal: please move this Q/A session to lispcafe or somewhere else mroe appropriate
<jackdaniel>
no-defun-allowed: same applies to you
dmiles has joined #lisp
<equwal>
jackdaniel: we did this here because a regular cannot send messages, seemed relevant.
davepdotorg has joined #lisp
<jackdaniel>
we've concluded that he can't, we do not discuss here "how to configure irssi", how to "start irc client" etc
<easye>
equwal: comments like "We at the #lisp channel kindly think you should use Common Lisp instead of your stack." will probably be counterproductive to helping address your issues.
<easye>
But I guess we all need our snark with our morning quark.
<equwal>
I guess I got enough flame in during the body of the thing.
<aeth>
I mean, it worked out well for the Rust community. In that, "Why don't you rewrite it in Rust?" literally became a meme.
<equwal>
We could adopt that strategy
heisig has joined #lisp
<equwal>
Add it to every bug report you make
knicklux has joined #lisp
ldb has joined #lisp
random-nick has joined #lisp
<aeth>
When you learn a new programming language, you're less productive than when using a programming language you already know. For months. So suggestions to rewrite a project in another language will almost always be rejected, rationally, since it's irrational to do so.
<aeth>
Now, of course, lots of people will willingly be temporarily irrational.
<equwal>
That is like saying it is irrational to climb down from a low hill in order to cross a valley and go up a higher peak.
<equwal>
If you are trying to get really high, I would consider such a thing rational.
<aeth>
It's almost always too late to rewrite any already-existing, significant project.
<equwal>
I can agree with that.
<aeth>
Few are going to accept many months of no progress, perhaps a year or more, just to change non-user-visible details while ideally locking the API into a 100% stable state so that the rewrite can match the existing API/tests/etc.
<aeth>
Now, of course, someone else could write a compatible version in another language.
fookara has quit [Read error: Connection reset by peer]
<ldb>
no-defun-allowed: i can send via irssi. it's just my laptop can't have a stable irc connection
bendersteed has joined #lisp
rumbler31 has joined #lisp
davepdotorg has quit [Ping timeout: 272 seconds]
prince1 has joined #lisp
rumbler31 has quit [Ping timeout: 255 seconds]
prince1 has quit [Ping timeout: 240 seconds]
<tourjin>
l (sb-grovel::foreign-nullp dirent) shows me error message like this . The function SB-GROVEL::FOREIGN-NULLP has been deprecated as of SBCL version 1.2.15.
<tourjin>
Use SB-ALIEN:NULL-ALIEN instead. so I changed it (sb-alien:null-alien dirent) but still shows error message. what did I miss?
<no-defun-allowed>
Do you need to use SB-ALIEN and SB-POSIX to get a directory listing?
<no-defun-allowed>
I don't believe you touch SB-GROVEL at all, either.
varjag has joined #lisp
<Shinmera>
Is this an alt of that other dude that just tried to do things with FFI for no reason without knowing any lisp at all and never took advice either
<no-defun-allowed>
tourjin: Stop sending me private messages.
<tourjin>
i see. sorry for that.
rippa has joined #lisp
v_m_v has joined #lisp
retropikzel has joined #lisp
orivej has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 255 seconds]
retropikzel has quit [Remote host closed the connection]
retropikzel has joined #lisp
markoong has joined #lisp
heisig has quit [Quit: Leaving]
_whitelogger has joined #lisp
ldb has quit [Quit: leaving]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
ggole has joined #lisp
cosimone has joined #lisp
retropikzel has quit [Quit: Leaving]
markong has joined #lisp
markoong has quit [Ping timeout: 256 seconds]
markong has quit [Ping timeout: 268 seconds]
v88m has quit [Ping timeout: 256 seconds]
Bike has joined #lisp
randomname321 has joined #lisp
randomname321 has left #lisp [#lisp]
g0d_shatter has joined #lisp
g0d_shatter has quit [Quit: Leaving]
jmercouris has joined #lisp
wxie has joined #lisp
xlei has quit [Ping timeout: 268 seconds]
prince1 has joined #lisp
retropikzel has joined #lisp
prince1 has quit [Ping timeout: 240 seconds]
zaquest has joined #lisp
xlei has joined #lisp
v88m has joined #lisp
Necktwi has quit [Read error: Connection reset by peer]
X-Scale` has joined #lisp
ebzzry has joined #lisp
X-Scale has quit [Ping timeout: 255 seconds]
X-Scale` is now known as X-Scale
v88m has quit [Ping timeout: 260 seconds]
cosimone has quit [Quit: Terminated!]
v_m_v has quit [Remote host closed the connection]
hsaziz has joined #lisp
hsaziz has quit [Client Quit]
ebzzry has quit [Read error: Connection reset by peer]
Inline has quit [Ping timeout: 246 seconds]
rumbler31 has joined #lisp
shidima has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
varjag has quit [Read error: Connection reset by peer]
varjagg has joined #lisp
ebzzry has joined #lisp
v88m has joined #lisp
wxie has quit [Ping timeout: 258 seconds]
wxie has joined #lisp
dddddd has joined #lisp
luni has joined #lisp
lucasb has joined #lisp
jmercouris has quit [Remote host closed the connection]
davepdotorg has joined #lisp
gravicappa has quit [Ping timeout: 265 seconds]
ljavorsk has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
davepdotorg has quit [Ping timeout: 272 seconds]
prince1 has joined #lisp
cosimone has joined #lisp
prince1 has quit [Ping timeout: 256 seconds]
buffergn0me has joined #lisp
retropikzel has quit [Read error: Connection reset by peer]
retropikzel has joined #lisp
EvW has joined #lisp
KDr2 has quit [Remote host closed the connection]
KDr2 has joined #lisp
sarna_ has joined #lisp
Bourne has quit [Ping timeout: 260 seconds]
sarna has quit [Ping timeout: 272 seconds]
sarna_ is now known as sarna
slyrus_ has joined #lisp
slyrus__ has quit [Ping timeout: 240 seconds]
slyrus__ has joined #lisp
igemnace has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
Bourne has joined #lisp
igemnace has quit [Client Quit]
Necktwi has joined #lisp
igemnace has joined #lisp
EvW has quit [Quit: EvW]
EvW1 has joined #lisp
cosimone has quit [Quit: Terminated!]
retropikzel has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
retropikzel has joined #lisp
shangul has quit [Remote host closed the connection]
slyrus_ has joined #lisp
rumbler31 has quit [Ping timeout: 265 seconds]
slyrus__ has quit [Ping timeout: 265 seconds]
shangul has joined #lisp
shidima has quit [Remote host closed the connection]
bitmapper has joined #lisp
retropikzel has quit [Quit: Leaving]
retropikzel has joined #lisp
domovod has joined #lisp
ljavorsk has quit [Remote host closed the connection]
heisig has joined #lisp
Jonsky has joined #lisp
ebrasca has quit [Remote host closed the connection]
<grumpyvegetable>
Does CL have a help menu embedded in the interpreter like Python does?
ljavorsk has quit [Ping timeout: 255 seconds]
<aeth>
CL uses DESCRIBE for interactive help, but the quality of DESCRIBE for the built-ins depends on the implementation and is fairly poor outside of the commercial implementations afaik. Generally, people use the HyperSpec or some processed form of the HyperSpec to be embedded into your IDE. Some implementations even launch the HyperSpec when you do DESCRIBE on a built-in.
<aeth>
Note that that is a very early webpage that has basically only been updated once since its 1996 launch, to remove the colored background and change the icons from purple to light blue. It's a very dated webpage.
gabc_ has left #lisp [#lisp]
EvW has joined #lisp
thecoffemaker has joined #lisp
slyrus__ has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
karlosz has quit [Quit: karlosz]
cosimone has quit [Quit: Terminated!]
heisig has joined #lisp
karlosz has joined #lisp
thecoffemaker has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
davepdotorg has joined #lisp
efm has quit [Remote host closed the connection]
prince1 has joined #lisp
davepdotorg has quit [Ping timeout: 272 seconds]
thecoffemaker has joined #lisp
prince1 has quit [Ping timeout: 250 seconds]
prince1 has joined #lisp
void_pointer has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
amnesia101101[m] has joined #lisp
random-nick has quit [Ping timeout: 255 seconds]
igemnace has quit [Quit: WeeChat 2.7.1]
random-nick has joined #lisp
orivej has joined #lisp
knicklux has quit [Quit: Leaving]
cosimone has quit [Remote host closed the connection]