rpg has quit [Read error: Connection reset by peer]
aeth has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
jeosol has joined #lisp
wsinatra has joined #lisp
wsinatra has quit [Client Quit]
beach has joined #lisp
wsinatra has joined #lisp
Alfr_ has joined #lisp
wsinatra has quit [Client Quit]
mrchampion has quit [Ping timeout: 256 seconds]
mister_m` has quit [Remote host closed the connection]
wsinatra has joined #lisp
<beach>
Good morning everyone!
wsinatra has quit [Client Quit]
mrchampion has joined #lisp
Alfr has quit [Ping timeout: 258 seconds]
wsinatra has joined #lisp
wsinatra has quit [Client Quit]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<recalloc>
I've found a library that depends on both trivial-utf-8 and babel, so I thought I'd go through moving all the trivial-utf-8 stuff over. Is it safe to assume the special variable babel:*default-encoding* will remain UTF-8, or should I explicitly set the encoding each call, or is there a way to dynamic-bind that variable for a whole file?
aeth has quit [Ping timeout: 272 seconds]
rumbler31 has quit [Remote host closed the connection]
aeth has joined #lisp
skapata has quit [Remote host closed the connection]
rumbler31 has joined #lisp
epony has joined #lisp
spectra26 has joined #lisp
<jasom>
recalloc: there is no such thing as a dynamic binding for a "whole file" since a file is a lexical unit. For a library you'll pretty much have to specify the encoding every time because you can't rely on consumers of your library not changing the default.
saganman has quit [Quit: WeeChat 1.6]
saganman has joined #lisp
<recalloc>
jasom: Aight, I suppose I figured the worst-case was right. Fortunately I don't call it enough times to make it a bother
veera has quit [Ping timeout: 240 seconds]
jerme_ has quit [Read error: Connection reset by peer]
veera has joined #lisp
jerme_ has joined #lisp
sz0 has quit [Ping timeout: 240 seconds]
<recalloc>
babel and trivial's relevant API is very close, fortunately. Looks like the tests all pass and my dependent project doesn't break either.
sz0 has joined #lisp
alanz has quit [Read error: Connection reset by peer]
<recalloc>
Fukamachi was active less than a week ago to GitHub, so I'm hoping it gets his approval
spectra26 has quit [Ping timeout: 240 seconds]
<jasom>
if trivial-utf-8 is faster than babel, he might reject it.
wsinatra has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
alanz_ has quit [*.net *.split]
waleee-cl has quit [*.net *.split]
larme has quit [*.net *.split]
lowryder_ has quit [*.net *.split]
v3ga has quit [*.net *.split]
bjorkintosh has quit [*.net *.split]
midre has quit [*.net *.split]
specbot has quit [*.net *.split]
grobe0ba has quit [*.net *.split]
edgar-rft has quit [*.net *.split]
ey[m] has quit [*.net *.split]
flip214 has quit [*.net *.split]
penguwin has quit [*.net *.split]
fiddlerwoaroof has quit [*.net *.split]
<recalloc>
That's true. Regardless of whether he rejects it, I think I've done my part. Unless I can convince that babel is somewhat faster or comparable.
waleee-cl has joined #lisp
larme has joined #lisp
alanz_ has joined #lisp
bjorkintosh has joined #lisp
lowryder_ has joined #lisp
specbot has joined #lisp
v3ga has joined #lisp
edgar-rft has joined #lisp
ey[m] has joined #lisp
grobe0ba has joined #lisp
fiddlerwoaroof has joined #lisp
flip214 has joined #lisp
penguwin has joined #lisp
midre has joined #lisp
Aurora_v_kosmose has quit [Remote host closed the connection]
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
dieggsy has quit [Ping timeout: 240 seconds]
stargazesparkle has quit [Ping timeout: 244 seconds]
eymebolofscrumpe has quit [Ping timeout: 246 seconds]
quanta[m] has quit [Ping timeout: 246 seconds]
ey[m] has quit [Ping timeout: 253 seconds]
nckx has quit [Ping timeout: 264 seconds]
Lolicon[m] has quit [Ping timeout: 246 seconds]
arichiardi[m] has quit [Ping timeout: 260 seconds]
Aurora_v_kosmose has joined #lisp
nckx has joined #lisp
ThaEwat has quit [Ping timeout: 246 seconds]
infra_red[m] has quit [Ping timeout: 268 seconds]
94KAABSF3 has quit [Ping timeout: 260 seconds]
chipk[m] has quit [Ping timeout: 260 seconds]
posthuman_egrego has quit [Ping timeout: 265 seconds]
18WABNFN4 has quit [Ping timeout: 272 seconds]
etimmons has quit [Ping timeout: 260 seconds]
solideogloria[m] has quit [Ping timeout: 264 seconds]
susam has quit [Ping timeout: 260 seconds]
anunnaki has quit [Ping timeout: 246 seconds]
<recalloc>
My project indirectly depends on both puri and quri, but because of how it's organized, I see no good way of migrating a system from one dependency to the other
christopheroei[m has quit [Ping timeout: 240 seconds]
<recalloc>
lispcord requires websocket-driver-client requires quri, but also lispcord requires drakma requires puri. Less a matter of technically migrating the dependency, but more about encouraging either drakma or websocket to move to the other
ms[m] has quit [Ping timeout: 240 seconds]
MrtnDk[m] has quit [Ping timeout: 240 seconds]
kaisyu[m] has quit [Ping timeout: 240 seconds]
<recalloc>
So I think the best action is to leave it as-is.
theothornhill[m] has quit [Ping timeout: 265 seconds]
anotherone9999[m has quit [Ping timeout: 265 seconds]
loke[m] has quit [Ping timeout: 268 seconds]
even4void[m] has quit [Ping timeout: 268 seconds]
bitmapper has quit [Quit: Connection closed for inactivity]
<recalloc>
Oh, I see someone else has bothered to do it for me 5 years ago
<recalloc>
6 years*, it's 2021
ey[m] has joined #lisp
stargazesparkle has joined #lisp
dieggsy has joined #lisp
CookE[] has quit [Remote host closed the connection]
CookE[] has joined #lisp
carkh has quit [Remote host closed the connection]
CookE[] has quit [Remote host closed the connection]
hendursaga has quit [Remote host closed the connection]
CookE[] has joined #lisp
hendursaga has joined #lisp
chipk[m] has joined #lisp
etimmons has joined #lisp
carkh has joined #lisp
epony has joined #lisp
M18WABNFN4 has joined #lisp
M94KAABSF3 has joined #lisp
arichiardi[m] has joined #lisp
posthuman_egrego has joined #lisp
ThaEwat has joined #lisp
quanta[m] has joined #lisp
eymebolofscrumpe has joined #lisp
zacts has joined #lisp
Lolicon[m] has joined #lisp
infra_red[m] has joined #lisp
anotherone9999[m has joined #lisp
theothornhill[m] has joined #lisp
aartaka has joined #lisp
hendursaga has quit [Remote host closed the connection]
solideogloria[m] has joined #lisp
susam has joined #lisp
hendursaga has joined #lisp
jdormit has joined #lisp
katco has joined #lisp
dmiles[m] has joined #lisp
Gnuxie[m] has joined #lisp
deselby has joined #lisp
ms[m] has joined #lisp
ecm has joined #lisp
christopheroei[m has joined #lisp
kaisyu[m] has joined #lisp
MrtnDk[m] has joined #lisp
even4void[m] has joined #lisp
loke[m] has joined #lisp
gioyik has quit [Quit: WeeChat 3.0]
gioyik has joined #lisp
orivej has joined #lisp
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
gioyik_ has joined #lisp
gioyik has quit [Ping timeout: 268 seconds]
gaqwas has joined #lisp
gaqwas has joined #lisp
lad has left #lisp ["Leaving"]
CookE[] has quit [Remote host closed the connection]
CookE[] has joined #lisp
gioyik_ has quit [Quit: WeeChat 3.0]
Bike has quit [Quit: Lost terminal]
Blukunfando has quit [Ping timeout: 272 seconds]
cantstanya has quit [Remote host closed the connection]
madage has quit [Remote host closed the connection]
madage has joined #lisp
cantstanya has joined #lisp
texno has quit [Ping timeout: 246 seconds]
narimiran has joined #lisp
pfdietz has quit [Quit: Ping timeout (120 seconds)]
jeosol has quit [Quit: Ping timeout (120 seconds)]
aggin has quit [Quit: WeeChat 3.0]
waleee-cl has quit [Quit: Connection closed for inactivity]
long4mud has quit [Ping timeout: 272 seconds]
long4mud has joined #lisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
aartaka_d has joined #lisp
CookE[] has quit [Remote host closed the connection]
bilegeek has quit [Quit: Leaving]
hendursa1 has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
hendursaga has quit [Ping timeout: 268 seconds]
zdm has quit [Ping timeout: 276 seconds]
zdm has joined #lisp
nckx has quit [Ping timeout: 276 seconds]
nckx[2] has joined #lisp
ski has quit [Ping timeout: 276 seconds]
dbotton has quit [Quit: Leaving]
ski has joined #lisp
shka_ has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
nckx[2] is now known as nckx
mathrick has quit [Ping timeout: 246 seconds]
_Posterdati_ is now known as Posterdati
theothornhill has joined #lisp
devon has quit [Remote host closed the connection]
attila_lendvai_ has joined #lisp
theothor` has joined #lisp
theothornhill has quit [Read error: Connection reset by peer]
rumbler31 has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
anticrisis has quit [Read error: Connection reset by peer]
<contrapunctus>
Hm, I can't seem to figure out how to use `legit` to get the repository tree. I tried `git-ls-tree`, but I'm not sure how to use that value...it's not a list of strings, or even a string, like I might expect 🤔
zacts has quit [Quit: leaving]
orivej has quit [Ping timeout: 272 seconds]
Major_Biscuit has joined #lisp
<phoe>
git-ls-tree? I can't see it in the current version of legit
<phoe>
basically: intercept the standard output, split by newline
<phoe>
that's a common idiom to do with Lisp programs that print to *s-o*
aartaka has joined #lisp
<phoe>
oh, seems like you can use legit:*git-output* instead of *s-o*
<phoe>
that works too
aartaka_d has quit [Ping timeout: 272 seconds]
cchristiansen has joined #lisp
lavaflow has quit [Ping timeout: 256 seconds]
<contrapunctus>
phoe: say, why are there parens around `*standard-output*` in your example? 🤔
jonatack has joined #lisp
<contrapunctus>
Oh nevermind
lavaflow has joined #lisp
<contrapunctus>
(The arglist is `(var &optional string-form &key element-type) declaration* form*` and not, as I imagined, `(var &optional string-form &key element-type declaration* form*)` 😅)
pve has joined #lisp
mathrick has joined #lisp
surabax has joined #lisp
ralt has joined #lisp
chipk[m] has quit [Quit: Idle for 30+ days]
Major_Biscuit has quit [Quit: WeeChat 2.9]
theothor` has quit [Remote host closed the connection]
hendursa1 has joined #lisp
jonatack_ has joined #lisp
heisig has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
toorevitimirp has quit [Ping timeout: 246 seconds]
toorevitimirp has joined #lisp
jonatack_ has quit [Client Quit]
jonatack_ has joined #lisp
jonatack_ has quit [Client Quit]
hendursaga has joined #lisp
jonatack has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
rgherdt has quit [Remote host closed the connection]
hendursa1 has quit [Ping timeout: 268 seconds]
karlosz has quit [Ping timeout: 256 seconds]
narimiran has quit [Quit: leaving]
ljavorsk has joined #lisp
Major_Biscuit has joined #lisp
frgo has joined #lisp
iamFIREcracker has joined #lisp
rumbler31 has joined #lisp
ljavorsk has quit [Remote host closed the connection]
ljavorsk has joined #lisp
frodef`` has quit [Ping timeout: 256 seconds]
<phoe>
`(var &optional ... &key ... &body forms)` would be one crazy macro lambda list
<contrapunctus>
Hahaha
attila_lendvai_ has quit [Ping timeout: 265 seconds]
aeth has quit [Ping timeout: 240 seconds]
jello_pudding has quit [Ping timeout: 264 seconds]
attila_lendvai_ has joined #lisp
fourier has quit [Remote host closed the connection]
aeth has joined #lisp
Nilby has joined #lisp
catt has joined #lisp
villanella has joined #lisp
aeth has quit [Ping timeout: 272 seconds]
aeth has joined #lisp
toorevitimirp has quit [Ping timeout: 265 seconds]
jello_pudding has joined #lisp
frgo has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
cchristiansen has quit [Read error: Connection reset by peer]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<contrapunctus>
I figured I could remove the choice paralysis by using CLOS to define multiple backends, thus being able to use any kind of Git library (or even other VCS libraries)
gj has joined #lisp
abhixec has quit [Ping timeout: 240 seconds]
ikrabbe has joined #lisp
attila_lendvai_ has quit [Ping timeout: 246 seconds]
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
pankajsg has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
saganman has quit [Ping timeout: 264 seconds]
cosimone has joined #lisp
t3hyoshi has joined #lisp
h4ck3r9696 has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
gaqwas has quit [Remote host closed the connection]
vegansbane6963 has joined #lisp
frgo has quit [Ping timeout: 240 seconds]
holycow has joined #lisp
holycow has quit [Client Quit]
Alfr_ has quit [Quit: Leaving]
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #lisp
Guest28077 has joined #lisp
Guest28077 has quit [Connection closed]
Wezl has joined #lisp
x49F has joined #lisp
x49F has quit [Connection closed]
nirved has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
saganman has joined #lisp
frgo has joined #lisp
wfranken has joined #lisp
wfranken has quit [Connection closed]
iownall555 has joined #lisp
jonatack has quit [Quit: jonatack]
pve has quit [Ping timeout: 264 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
jonatack has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
iskander- has joined #lisp
aeth has quit [Ping timeout: 256 seconds]
iskander has quit [Ping timeout: 256 seconds]
jeosol has joined #lisp
aeth has joined #lisp
igemnace has quit [Quit: WeeChat 3.0]
frgo has quit [Ping timeout: 260 seconds]
jonatack has quit [Ping timeout: 272 seconds]
jonatack has joined #lisp
frgo has joined #lisp
rogersm_ has joined #lisp
madage has quit [Remote host closed the connection]
madage has joined #lisp
waleee-cl has joined #lisp
rogersm_ has quit [Client Quit]
dhil has joined #lisp
nij has joined #lisp
pve has joined #lisp
<nij>
Good morning! How do I inspect a CL program? Stumpwm has been shooting my CPU to 200% and heating my machine, for example. I can connect to it through a swank/slynk server. Hopefully I can look into its internal.
buriedalive has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
buriedalive has quit [Connection closed]
amb007 has joined #lisp
jeosol has quit [Quit: Connection closed]
amb007 has quit [Read error: Connection reset by peer]
<Xach>
nij: one option is to interrupt each thread to print or save a backtrace - that can give you an idea of who is doing what work
<Xach>
nij: i don't have a one-liner or key to do that, sorry
amb007 has joined #lisp
nirved has quit [Remote host closed the connection]
<nij>
can i expect to see *ALL* threads by (sb-thread:list-all-threads)? Just to double check.
<Xach>
yes
nirved has joined #lisp
<nij>
COOL. In emacs there's some profiling tool. Wonder if there's any here.
wsm has joined #lisp
<wsm>
/!\ this channel has moved to ##hamradio /!\
wsm has quit [Remote host closed the connection]
<Xach>
I am not moving.
equwal has joined #lisp
frgo has quit []
amb007 has quit [Read error: Connection reset by peer]
jonatack has quit [Ping timeout: 272 seconds]
aeth has quit [Ping timeout: 240 seconds]
ukari has quit [Remote host closed the connection]
amb007 has joined #lisp
aeth has joined #lisp
AuctusBS has joined #lisp
EvilWerezombieQy has joined #lisp
<AuctusBS>
/!\ this channel has moved to #nyymit /!\
ukari has joined #lisp
<EvilWerezombieQy>
/!\ this channel has moved to #nyymit /!\
AuctusBS has quit [Remote host closed the connection]
<Xach>
What on earth.
orboZ has joined #lisp
<orboZ>
/!\ this channel has moved to #nyymit /!\
EvilWerezombieQy has quit [Remote host closed the connection]
<nij>
/|\ <== this symbol reminds me of road trip
orboZ has quit [Remote host closed the connection]
<nij>
wonder when we can do that soon
Theking^eQ has joined #lisp
<ck_>
I bet they don't even socially distance the nicknames in those other channels
<Theking^eQ>
/!\ this channel has moved to #nyymit /!\
<nij>
ck_: lol
Theking^eQ has quit [Remote host closed the connection]
hjudt has joined #lisp
orivej has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
Bike has joined #lisp
<Inline>
hewww
<Inline>
i got my makerlisp machine
<Inline>
hahaha :)
<phoe>
show me!
dra has joined #lisp
<flip214>
how about all joining and leaving that advertized channel repeatedly? should make quite a mess of the channel logs...
<phoe>
I have all joins/leaves ignored
<phoe>
also #freenode says that the spam attack seems over for now
nirved has quit [Remote host closed the connection]
<nij>
Xach: I turned on another sly, and list all threads. It turns out that the only two different threads in the old instance are called "Mixer thread 44,100 Hz".
<nij>
But while I inspect, there doesn't seem to be useful information.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
nirved has joined #lisp
contrapunctus has joined #lisp
nirved has quit [Remote host closed the connection]
luna_is_here has quit [Quit: luna_is_here]
luna_is_here has joined #lisp
<phoe>
try calling bt:interrupt-thread #'break on those threads
<phoe>
and see if the CPU usage drops
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
bitmapper has joined #lisp
<nij>
Seems that it's destroyed.. and CPU drops from 200% to 0.2%
<nij>
wish I can see what it's playing behind the scene before it died
<phoe>
you can continue in the debugger
<phoe>
or rather
<phoe>
you can inspect the backtrace in the debugger!
<phoe>
maybe that will give you some info
caret has joined #lisp
<nij>
but.. but it's dead
<nij>
lemme see how I can make it alive again
<phoe>
dead?
<phoe>
oh, did you kill it?
<phoe>
BREAK doesn't kill threads on its own, it just places them in the debugger
<nij>
uh I called (sbcl-thread:interrupt-thread <that annoying thread> nil)
<nij>
and a menu is up, asking me what to do next
<nij>
i guess i chose one that killed it then :-(
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
<phoe>
oop
<Bike>
sb-thread:interrupt-thread takes a function for its second argument. i think nil would be an error?
<nij>
ooop..
<nij>
I will wait for it to come out next time. It has been present yesterday too, but i just killed the whole stumpwm.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<nij>
Threads are tricky. Isn't there a way to see its whole history? Like which functions it inboked, which outputs it has generated.. etc?
contrapunctus has joined #lisp
<Bike>
if every thread recorded that stuff the system would be way slower.
<Bike>
certainly they wouldn't be running at 44 kHz
ljavorsk has quit [Ping timeout: 246 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
<flip214>
nij: Bike: I'd really love for SBCL to generate DWARF information - then this could be fetched via perf and similar tools, without too heavy performance impacts
contrapunctus has left #lisp ["Disconnected: closed"]
random-nick has joined #lisp
contrapunctus has joined #lisp
jonatack has joined #lisp
* nij
is trying to read up what DWARF is. Hang on folks.
* nij
has to read up stuff quite often. The amount of new terminologies, to him, seem infinite.
<Bike>
it's a format for recording debugging information
<nij>
yep that's what i know so far
<Bike>
flip214 is probably thinking of things like dtrace that can get "samples" of what a process is doing from outside
<nij>
DTRACE! Another term :D
<Nilby>
I don't think lisp matches very well with the way DWARF works. It might be better to do it with a lisp tool, perhaps using techniques like sb-sprof.
<nij>
Bike: yeah but as you said, if everything is logged, then the speed is bad.
<nij>
So the problem is.. what are the things that must be logged?
<flip214>
Nilby: as long as you don't recompile, dwarf information should be good enough - especially when running a full image.
<Bike>
we use dwarf in clasp and it works alright, though we don't present as much information as we ought to yet
<flip214>
perf just records instruction pointers via frame pointers, but from kernel space, deduplicates stack traces, and lets userspace resolve them to names.
scymtym has quit [Ping timeout: 272 seconds]
wsinatra has joined #lisp
<Nilby>
But DWARF stuff will only be there for things done compile-file? Or does it get dynamic stuff?
<nij>
Debugging, profiling, logging, testing - These seem to be a broader/generaler discipline. I should read some general information up I guess. I'm self-taught in CS.. could you recommend some reference that's great about this?
<nij>
Like.. I read the CL cookbook on those topics, but they seem too specific. I don't even have the general idea of what should be done.
Inline has quit [Quit: Leaving]
Inline has joined #lisp
<nij>
I feel like this is more for #clschool, so I'll move this here. Sorry folks!
mister_m has joined #lisp
<nij>
Inline: How's your makerlisp machine going?
<flip214>
Nilby: it should save all current function names with their ranges, at least. if you do that after dynamically compiling functions, they should be included.
<flip214>
at least that's my wish.
wsinatra has quit [Quit: WeeChat 3.0.1]
<Inline>
nij: i got the full machine in a wood enclosure everything is already set up, vga-board, usb-controller-board with the usb key etc...
<Inline>
nij: i just need to find a suitable usb keyboard which fits the enclosure
scymtym has joined #lisp
wsinatra has joined #lisp
<Inline>
nij: no idea but on first glance i couldn't find anything suitable on amazon or ebay yet
<Inline>
nij: doesn't have to be retro just fitting
<Bike>
Nilby: you can generate it for stuff like COMPILE, there's just no source info
<Bike>
so it'll just have where variables are and such
<Inline>
nij: and i have to order some of the quality breadboards too
<nij>
Inline: exciting!
<nij>
There should be more info coming out. I wonder what it can do (besides of fun).
pankajsg has joined #lisp
<Inline>
nij: cause i have a lab breadboard down in my cellar, and i supplied voltage from my soldering station to it (since it can do that) but the lanes are not getting voltage or something else is not ok with it (some lanes do get voltage but not all)
cosimone_ has joined #lisp
<Inline>
heh
<nij>
heh
<Inline>
slowly but steadily i think i will complete all the needed parts in order to get started with some hobby electronics thing
<Inline>
not sure how far i can get with it, and i also discovered my eyes are not so good when looking at stuff from very near
<Inline>
so i suppose i got to get a zooming lens too or so
<nij>
sounds like a whole lot of fun!
<Inline>
ja but it takes a whole lotta time ....
lisp-machine has joined #lisp
<Inline>
especially since covid .....
<nij>
for shipping?
cosimone has quit [Ping timeout: 260 seconds]
cosimone_ is now known as cosimone
<Inline>
yes
<Inline>
ofc
<nij>
oh.. :-( Here in the states amazon and ebay still deliver fast
<nij>
dunno about overseas..
karlosz has joined #lisp
<nij>
is there any OS that you can run on makerlisp already?
<Inline>
well it's fast enough yet
<Inline>
i mean still
<Inline>
meh
<Inline>
you can run CP/M on it
<Inline>
since it's a Z80 machine
<Inline>
lol
ebrasca has joined #lisp
<Inline>
i suppose that's already installed even
<Inline>
i just need another sdcard for that device, have to look what the format is
<nij>
how about any lispos?
karlosz has quit [Ping timeout: 256 seconds]
<lisp-machine>
nij what is lispos?
<Inline>
no idea nij
Major_Biscuit has quit [Ping timeout: 264 seconds]
<Nilby>
nij: 8bit machines don't typically run an os in the sense you might think, they usually run one program at a time, one of which could be a thing that manipulates files and starts/boots other programs.
<Inline>
it has a builtin interpreter compatible with cl/scheme
<Inline>
hope i can find some documentation about it too
<Inline>
it has an analog display, so the precision is not given like on a power bench
<lisp-machine>
nij: ahh yes ik that list
<Inline>
so if i should be in need of precise voltages then i have to i think
<lisp-machine>
but is there any lisp os that can actually be a daily driver?
<Inline>
there's mezzano
<Inline>
you can already put that on a usb stick or so
<lisp-machine>
Inline: right, but can you run non-mezzano software on it? or is it a closed ecosystem?
<nij>
I'm also wondering about that..
<Inline>
i tested it a few times in qemu already
<Inline>
and it works, but the config is not easy, to change keyboard layout you have to edit some file etc etc..
<nij>
Does any of them run x11?
<ebrasca>
nij: Mezzano does run bare metal.
<lisp-machine>
and how user-friendly is it? that's what most people care about.
<lisp-machine>
for a lisp os to become mainstream, it will have to be easy to use
<Inline>
jep bare metal, but still it need more drivers and driver-frameworks or so
<phoe>
>mainstream
<phoe>
forget about it unless you have major commercial backing
<lisp-machine>
sadly not everyone is a computer/programming geek like us
<nij>
i'd say true lispers are geeks among geeks among geeks.
<nij>
Does the population supercedes 10,000, in the whole world?
<phoe>
lisp-machine: either you have the heaps of money to get the required corporate backing, write or port all the software for that OS and to make the OS robust and secure and fast enough, or you don't get to make anything mainstream.
<lisp-machine>
nij: '(geek (geek (geek)))
<Inline>
even if i supply -kbd de from qemu you have to change it manually too, otherwise you have a horrible mixture and confusion
<Inline>
heh
<nij>
Inline: you should write a blog on that
<lisp-machine>
phoe: yeah ik, i was just theorizing and discussing. I don't actually plan on making a mainstream os lol.
<nij>
i got envious just by listening
<phoe>
you're not the first nor the last to theorize and dream about a lisp OS :D
<nij>
Ha ha
<lisp-machine>
of all the programming languages it's a great candidate for writing an os; maybe you could even write an os that's simply a running lisp repl (obviously that's a major oversimplification, but still...).
<phoe>
well, mezzano is a proof that it can be done with relatively little code - see the recent hacker news discussion o it
<phoe>
on it*
<lisp-machine>
ah
<phoe>
the issue is, as always, not enough people to do the boring work related to it
<lisp-machine>
but who wants to do boring work, for free?? :D
<nij>
But w ecan start making lisp repl as our main shell.
lisp-machine has left #lisp ["Leaving"]
<nij>
That would bring the experience closer to what you describe.
Aurora_v_kosmose has quit [Ping timeout: 268 seconds]
<Josh_2>
Can't say I understand how it works but I think it would be a good feature
iskander has joined #lisp
cosimone_ has joined #lisp
iskander- has quit [Ping timeout: 240 seconds]
<beach>
I wonder why my article on CLOSOS/LispOS seems to get more publicity than Mezzano. I mean, Mezzano exists, whereas CLOSOS is still vaporware. I know that CLOSOS suggests more advanced basic features than Mezzano does, but most people who speculate/dream about a LispOS probably haven't given much thought to such features.
villanella has joined #lisp
cosimone has quit [Ping timeout: 246 seconds]
cosimone_ is now known as cosimone
Aurora_v_kosmose has joined #lisp
h4ck3r9696 has quit [Quit: Leaving.]
<Nilby>
Things always seems to work better in my imagination.
<phoe>
the grass is always greener on the other side too
<Nilby>
I run a mostly lisp command-line setup on top of other os's, but the big hurdles are fully replacing emacs, a browser, and a window system.
<nij>
Theories are clean, elegant, and appealing.
<Gnuxie[m]>
Was it posted somewhere?
<nij>
When they got implemented, lots of dirty stuffs go around.
<nij>
Nilby: could you elaborate?
h4ck3r9696 has joined #lisp
<Nilby>
But Mezzano is coming along well, and can run Doom, so
<nij>
DOOM?
<phoe>
doom
<phoe>
ported from C via LLVM-IR
<flip214>
no python, ruby, json, javascript, and perl inbetween? sad.
<Josh_2>
I think my fridge can run doom
varjag has joined #lisp
<nij>
It seems that why Lisp is great is essentially because of structures.. can anyone correct me on this point?
villanella has quit [Ping timeout: 272 seconds]
<phoe>
structures?
<phoe>
what do you mean?
<nij>
In UNIX, communications among units are in the form of text, which lacks structures.
<nij>
So artificial transformations must be done, and that's pretty tedious and not flexible.
<phoe>
that isn't Lisp being good
<phoe>
that is Unix being horrible
<phoe>
you can structure your data with Lisp, Java, C++, Python, Perl, Haskell, Elm, C, literally almost every language out there
<nij>
xD
<phoe>
it's unix that tried to coerce everything into files and byte streams, and failed horribly at that.
<nij>
s/failed/succeeded/
<nij>
sadly
contrapunctus has left #lisp ["Disconnected: closed"]
<Gnuxie[m]>
If Unix had more parenthesis i'm sure a few people here would be dying to call masochism lisp
<phoe>
no, failed
<Inline>
eh ?
<phoe>
it tried to assume that everything is a file
<Inline>
you haven't tried GUIX then
<Nilby>
Lisp is great because it reflects how universes work on a fundamental level more thoroughly than most languages.
<Inline>
lol
<nij>
phoe: Well, but Lisp even preserves structures in its CODE.
<phoe>
that's why we e.g. have ioctls all around to pretend that you can do other things with a file than merely read, write, or execute it
<Inline>
btw nixos etc are all in the same ballpark by measure of descriptiveness....
<nij>
Inline: GUIX is still pretty much UNIX, no?
<Nilby>
But there are trouble with lisp structured pipelines also, like what structure do you want?
<phoe>
nij: code? what do you mean
jurov has joined #lisp
<phoe>
I bet $5 that the source code of unix also has some structs inside it
<Inline>
they are all descriptive, i.e. you describe stuff in files and that's how it sets up things
<phoe>
I bet $50 that linux does, too
<nij>
phoe: By code I mean the textual presentation of lisp expression.
<phoe>
oh, good
contrapunctus has joined #lisp
<phoe>
then C has those, too
<nij>
?
<phoe>
Linux/Unix/whatever has structures in the textual presentation of C code
<phoe>
you just can't easily interface with most of them from inside the bash shell - that's the difference.
<phoe>
you're isolated via a layer of shell, and shell usually pretends that everything is text rather than structured objects.
<phoe>
the Lisp REPL doesn't pretend so
<nij>
So instead of returning plain texts, we should return what?
<phoe>
objects!
<nij>
Lisp objects? Or Lisp codes?
<phoe>
what do you mean, Lisp codes
<phoe>
every Lisp expression is a Lisp object anyway
<nij>
but not vice versea
<nij>
can you lift any Lisp object back to a Lisp expression?
<Inline>
baaah
<Inline>
i ate another usb stick
<phoe>
well, trying to evaluate ((())) is going to signal an error
<Inline>
since yesterday 128Gb stick is gone, some sectors do not react
<Inline>
i suppose it overheated overnight when i left llvm compilation on it running....
<nij>
oop
<Inline>
i tried new formatting even that didn't work
<Inline>
neither fsck
<phoe>
oops, s/expression/form/
<phoe>
so even though ((())) is a valid object, it's not a Lisp form
<Inline>
it tries to fix some inode counts and then it's gone for ever
<nij>
phoe: Is any Lisp object a Lisp form?
<phoe>
no - as I said above, ((())) is not a form
<nij>
Hmm.. ok. If we return objects instead of texts..
<Nilby>
Inline: big usb sticks are more complicated that most people think. I have a paranoia that I always let them sit for a little while after writing data.
<phoe>
a form is an object that is meant to be evaluated
<phoe>
nij: do not overthink it
<nij>
How would different machines communicate?
fubbiquantz has joined #lisp
<phoe>
your REPL already does this
<phoe>
it returns objects that are then printed so you can take a peek at what is inside there
<nij>
phoe: Yeah, but how about different machines?
<phoe>
and there's always the issue of serialization/deserialization over the network; see e.g. CL-CONSPACK for one library that solves this
<nij>
Foundamentally it's just 0 and 1s. I don't know how other machines would be able to understand the Lisp objects I produce locally.
<Nilby>
i've been keeping up on working out, and now I a lift almost any lisp object
<Inline>
welp, given a consecutive byte series you have the problem of where to start and in how big chunks to eat it
<Inline>
given non-consecutive it gets more hairy even
<nij>
Nilby: now you can?
<nij>
haha ok it's a joke
<Inline>
np-hard ?
<Inline>
lol
<nij>
phoe ! It claims that "Conspack provides the ability to serialize and deserialize objects of any kind."
<nij>
Is this true?!?!?!?!?!
<Nilby>
😂
amb007 has quit [Read error: Connection reset by peer]
<Inline>
that's just for interpreting
amb007 has joined #lisp
<nij>
btw who is robert.strandh@gmail.com
<phoe>
nij: yes
<phoe>
as long as you teach it how to do it
<phoe>
nij: it's beach
<Inline>
if you have jump addresses encoded, then you have the problem of recognizing them and having the same instruction set etc...
<nij>
loving the blog
<Inline>
i suppose that would be the abi layer
<nij>
should binge it sometime
<Inline>
same with pointers/references etc etc
<nij>
phoe: Dang that means different machines can also exchange objects! at least in common lisp!?
<nij>
how about compiled objects? still yes?
<Josh_2>
nij: pretty sure everything is an object on windows
<phoe>
nij: what do you mean, compiled objects?
<phoe>
functions and such? these likely won't work
<nij>
eh.. like a compiled function. It's also a lisp object, right?
<phoe>
if you want to pass code around, use FASLs
<Bike>
it says "any kind" but it's in a section about CLOS
<phoe>
so likely this means classes and structures
<nij>
Bike: section name - CLOS and general objects
<Bike>
yeah, i mean, look at the rest though, it's all slots and stuff
<Bike>
i don't see how conspack could possibly de/serialize functions
<nij>
Yeah that's why i was confused.
<phoe>
Bike: not without going into implementation internals and ensuring that there's no closures in play and such
<nij>
There should be a way to do it.. hopefully it has existed already. Then machines can communicate by throwing Lisp objects at each other <3 <3 <3
<Bike>
even with internals it would be difficult. i mean, functions aren't even serializable by implementations, usually
<Bike>
through compile-file i mean
<nij>
that's bad
<phoe>
nij: erlang has it, but that's because erlang functions are much more constrained than Lisp ones
imode has joined #lisp
<phoe>
you can work around this though, just pass Lisp forms around and have the other Lisp image evaluate them
<Bike>
closures aren't so much a problem, but with literals and linking it'll get bad
<nij>
but each function, while constructed, was from an evaluation of a piece of CODE, right?
<nij>
Why don't we just ask the compiled function to remember that piece of code?
<phoe>
yes, ultimately a function is created when someone calls COMPILE or FUNCTION or COERCE or DEFUN or whatever
<Bike>
because the production of a function is dependent on the context in which it was created
<phoe>
but what Bike said, not all functions can be reproduced from their textual representation
<nij>
Bike: let it remember all the information?
<Bike>
if your function source has a macro form in it, say, and you've redefined the macro between producing the function and serializing it, reproducing the function from the source will get you a function with distinct behavior
<_death>
check out common-cold for serializable closures
* phoe
checks
<Bike>
"my latest hack"
<nij>
pull the environmental details whatever it needs to re-produce ?
andreyorst has quit [Quit: WeeChat 2.8]
<Bike>
there's a lot of the environment to remember
<Bike>
whether things are special, what things are functions, what symbol macros don't exist
<phoe>
nij: also, flinging functions around still does not solve everything
<phoe>
even if you could serialize, transmit, and deserialize (lambda () (read-byte-from-serial-port)) then I think you can imagine the trouble
<Nilby>
it's fun when you send your top level app object thru the network, and pops off of one screen on to the other
dra has quit [Remote host closed the connection]
andreyorst has quit [Quit: WeeChat 2.8]
M94KAABSF3 has quit [Quit: Idle for 30+ days]
eymebolofscrumpe has quit [Quit: Idle for 30+ days]
Lolicon[m] has quit [Quit: Idle for 30+ days]
<nij>
phoe: I cannot imagine the trouble.
varjag has quit [Remote host closed the connection]
<phoe>
nij: calling this function on different machines is going to produce different results
<nij>
I am still looking into the term RPC, but it's not clear to me how much it's achieved.
<phoe>
you basically tell the remote server which function it should run, and then wait for it to give you some results back
<phoe>
that's how swank works!
<Nilby>
RPC has achived quite a bit
<nij>
but how would the remote machine know what exactly is the prodedure to be run?
lisp-machine has joined #lisp
<Nilby>
for example NFS works that way with C rpc
<Nilby>
there's also multiple lisp versions of NFS
andreyorst has joined #lisp
<Bike>
the caller and the callee processes agree on a common language of behaviors, and then the caller just sends a message naming the behavior to be performed.
<Bike>
basically the caller only needs to name a procedure to run.
<phoe>
nij: in case of lisp, you pass it as a string
<nij>
how about the information that's in the closure?
<phoe>
the closure exists on the server side
<phoe>
the client doesn't need to know about it
<Nilby>
X11 is basically RPC
<phoe>
or, rather: it tells the server that it should access that closure and give back some results
<phoe>
e.g. by calling it!
<nij>
And while client needs info from the closure, it asks the server?
<phoe>
yes
ikrabbe has quit [Remote host closed the connection]
<phoe>
try the following in your REPL
<nij>
DANG! O_O eye opening
<phoe>
(let ((x 42)) (lambda () x))
<phoe>
(funcall *)
<phoe>
in both cases you are sending strings over swank
<phoe>
and yet the first string creates a functon object
<phoe>
and the second gives you the closed-over value
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
lisp-machine has quit [Quit: Leaving]
<nij>
how about functions over functions? Same, without a problem?
<Nilby>
also most web API's are like RPC, sometimes even with javascript sent in JSON
<phoe>
what do you mean, functions over functions?
<nij>
(let ((x #'some-func)) (lambda () x))
<phoe>
it's a value like any other
<_death>
I think it makes sense to distinguish RPC, which tries to make remoting "transparent", and can't but fail, from communication by message passing
<nij>
nah.......
<phoe>
again, #'some-func only exists on the server side
<nij>
yeah
<nij>
the client might need it at some point
<nij>
so it asks the server to give #'some-func
<phoe>
all you see is the string "#'some-func" or the string "#<FUNCTION SOME-FUNC>"
<nij>
however, the problem is that it's hard to deliver function as a whole
<phoe>
and you come back to the issue of serialization
<nij>
yeah
<nij>
so it breaks down?
<phoe>
yes, serializing state is a tough problem in general
contrapunctus has joined #lisp
<phoe>
*especially* in image-based programs where you essentially need to pack the whole image in the worst case
contrapunctus has left #lisp ["Disconnected: closed"]
<nij>
:-(
<phoe>
Erlang and other BEAM languages solve it by sending out functions in their bytecode-compiled format
<phoe>
but these functions are pure and do not depend on any global state, so it's easy to clean-cut a single function
<nij>
yeah
<nij>
If a function isn't pure, a closure should be sent.
<jackdaniel>
cl could send you whole heap and I think that would be brilliant
<phoe>
Lisp functions are more messy in this regard, also because they are machine-compiled in the general case
<_death>
"serialization" is often a bad solution.. more often it's better to define explicit messages or object layouts
<phoe>
^
contrapunctus has joined #lisp
<jackdaniel>
here is a function with a 8gb state
<nij>
_death: but that's unix?
<nij>
no
<Fade>
have any of you folks worked with cl-yesql?
<phoe>
Fade: I have
<_death>
nij: ?
<phoe>
what's unix?
<Fade>
I'm looking for a funcitonal example.
<phoe>
Fade: uh, I don't think I have anything working at this very moment...
<phoe>
in particular, you cannot and should not e.g. dereference pointers over the network
<nij>
phoe: OH! That's why we need a single address space, as in beach's essay.
<Nilby>
_death always coming through with the goods :)
lisp-machine has joined #lisp
<phoe>
nij: yes
<phoe>
two machines have two address spaces
<phoe>
(just like two C programs)
<phoe>
and you cannot easily merge them unless you also merge their GCs and what else
<nij>
_death: you keep a zettlekasten or somethin'?
<phoe>
and *that* would be messy and troublesome
<nij>
phoe: HMM
<nij>
Then I wouldn't say UNIX failed..
<nij>
at the end everything is still "text"
sjl has quit [Quit: WeeChat 2.3-dev]
cage_ has quit [Quit: Leaving]
<nij>
we just need to write some protocol to lift text to objects
<phoe>
it failed at the assumption that it is feasible to represent everything as streams of bytes
<lisp-machine>
is there a way I could "farm out" intensive task threads to different pcs?
<phoe>
especially with regard to internal representation
<phoe>
lisp-machine: check out swank-crew
<phoe>
and/or lfarm
<lisp-machine>
phoe, ok thanks!
<phoe>
<3
<lisp-machine>
:)
<_death>
nij: it's all in my internal representation :/
<nij>
_death: ha hehe
<nij>
(dump '_death)
<Nilby>
unix failed in that it wanted to be plan9/inferno, but the lisp ideas are mostly better, so instead we half-ass wanna-be lisp machine in the form javascirpt web browser
<nij>
did we?
cyraxjoe has quit [Read error: Connection reset by peer]
sjl has joined #lisp
epony has quit [Quit: upgrades]
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<_death>
Accept: application/lisp
<_death>
lispers should've invented a better graphql
<phoe>
technically yes, but everyone was busy complaining about unix, and then the first ai winter happened
<Fade>
the lisp machine could not have succeeded where unix did, because shipping a computer with a graphical display and enough ram to run genera was an impossible hurdle at the time.
<Fade>
the costs were too high.
<Fade>
also, lisp machines didn't make good servers, as delivered by symbolics and TI
fubbiquantz has quit [Ping timeout: 256 seconds]
heisig has quit [Quit: Leaving]
long4mud has quit [Quit: WeeChat 3.0]
<Fade>
I did, however, hear that the White House website ran on a symbolics computer right up through the end of Bill Clinton's administration.
<Nilby>
I think that hints at the deeper reasons. Funding for lisp was yank. Genera ran pretty sweet on alpha, even emulated. Genera could "easily" be ported to sbcl right now if it were "allowed".
<Fade>
there are good ideas in Genera
<Fade>
I doubt any of us would actually want to use it as our computational platform day to day, now, though.
<Fade>
backfilling the tools and utility space alone would be a fulltime job.
<nij>
Fade: how would that work? Many programs we're used to won't run.
<Fade>
natch
<Nilby>
I would. What utility space?
<Fade>
you may as well just start writing the utilities you need in McCLIM.
kingcons has quit [Ping timeout: 246 seconds]
<Fade>
webbrowser, compilers for C, C++
<Fade>
webservers
pankajsg has quit [Remote host closed the connection]
kingcons has joined #lisp
<Fade>
I guess zmacs could be modernised
<Nilby>
The hardest parts would be making a drivers for say nvidia, wifi, etc.
<Nilby>
where stuff is hidden in blobs
pankajsg has joined #lisp
<Fade>
if you want a lisp machine, the way forward is to take linux as a driver substrate, and write a userland on top of it.
<Nilby>
genera had a C compiler, web stuff
<Fade>
well, you can download Genera and run it. Try it out, and let us know how it goes.
<Nilby>
I can run it. Also folks around here have running Symbolics machines. The problem is like I said, drivers for new hardware. If you notice, that's the difficulty with Mezzano too.
<Fade>
that's a problem for everything that isn't inside the proprietary ecosystem.
<aeth>
You definitely want to run on top of Linux for the foreseeable future. And even if you switch to your own kernel one day, you still need to be able to run Linux apps without recompiling. Even Windows is trying to be compatible there these days.
<aeth>
Through wine, you also get most Windows stuff for "free" if you can run Linux stuff.
<Fade>
within the context of a Genera style lisp machine, a windows or linux application would be comically out of place.
<Fade>
but I do think that running on top of Linux is the only way that a lisp machine operating system would become a practical reality.
<Fade>
as neat as mezzano is.
<Nilby>
aeth: Yes, I basically agree. Although I wish it was Linux/wine on top of Genera
<aeth>
Fade: Yeah, but until you write a web browser that's fully comparable to Firefox or Safari or the many forks of Chromium, then your OS is completely unusable without being able to just run Firefox-for-Linux or whatever.
<aeth>
And some websites don't even function 100% correctly in Firefox because Chrome is a monopoly.
cage_ has joined #lisp
_whitelogger has joined #lisp
<nij>
Has anyone worked with Mac OS X? I want to estimate how hard it is to port stumpwm to macbooks.
<_death>
there's already a lisp web browser (closure).. it just needs some work
<nij>
_death: why not nyxt?
<_death>
nij: that's more like a browser shell
<phoe>
it wraps a giant blob of C++ code so it's not a pure "lisp browser" technically speaking
<aeth>
we're talking more about rendering engines than browsers
<Nilby>
nij: you can't run a window manager on macbooks unless its X11, so then you can just run stumpwm
<_death>
nij: personally I stay away from web browsers (see emacs-w3m) but I guess that's another avenue if you don't mind foreign code
<aeth>
I think you can bootstrap a web browser rendering engine by implementing your UI as a subset of HTML5 and just adding more features over time, naturally.
<aeth>
Might take like 10 years, but whatever.
<aeth>
As long as it's not for the "open web" it doesn't matter.
<nij>
Nilby: I mean.. it should be possible to hack stumpwm for it to work on MacOSX right?
<Nilby>
What window manager does macos native run?
<nij>
_death: why stay away?
<_death>
nij: I do use firefox/chromium in a strange, customized setup.. but the web is mostly dead for me
devon has joined #lisp
<nij>
Nilby: I dunno@@ but there are several that work iirc
<aeth>
_death: Well, you can avoid the web, but only if you implement a Python that's complete enough to run youtube-dl :-p
<aeth>
Despite the name, youtube-dl really does download videos from pretty much everywhere.
<Nilby>
nij: under macos without X11?
<nij>
_death: I don't really understand what you mean @@ Have you tried nyxt?
<_death>
nij: not sure it's on-topic anymore.. let's say my relationship with today's technology and the values promoted is.. ambivalent
<_death>
aeth: I have some erc hack to launch mpv for youtube links ;)
<aeth>
_death: idk about mpv, but apparently vlc just uses youtube-dl under the hood
<_death>
aeth: mpv does the same
<Nilby>
i'd say my relationship with today's technology is abusive (on both parts)
<aeth>
it's too hard for more than one project to keep up with working around the API changes in literally every site that hosts video ever
<aeth>
(well, at least non-DRMed video)
pankajsg has quit [Ping timeout: 256 seconds]
villanella has joined #lisp
<Nilby>
aeth: some can jwz.org/hacks/youtubedown
ghard has joined #lisp
<aeth>
Nilby: that's.... 4 sites
<aeth>
youtube-dl is literally everywhere, as I said
<aeth>
Trust me, it would be easier to make a Python-in-CL be able to run youtube-dl than it would be to duplicate that effort
<_death>
cl-python also needs some work
hiroaki has joined #lisp
<Josh_2>
Thats not a lisp library
<aeth>
As far as a LispOS goes, you absolutely need to reimplement-in-CL (or just support, but that's not as cool) Python, JavaScript, and probably POSIX shell.
<aeth>
Quite a few Linux distro scripts are also still written in Ruby and Perl.
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
skapata has joined #lisp
devon`` has quit [Ping timeout: 256 seconds]
<aeth>
The old LispOSes jut needed a C compiler...
devon```` has joined #lisp
Sheilong has joined #lisp
terpri has quit [Quit: Leaving]
hineios has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
Major_Biscuit has quit [Ping timeout: 246 seconds]
devon```` has quit [Ping timeout: 256 seconds]
Alfr has joined #lisp
<hineios>
Hi all, can someone explain to me why the first FORMAT outputs the correct amount of whitespace and the second one doesn't?
<hineios>
I've tested with both ACL and SBCL and I have the same result.
<aeth>
oh, wow, that's a really good question
<hineios>
Its weird... if there are no format directive/argument afterwards it just does print the spaces...
terpri has joined #lisp
<phoe>
this seems wonky
<phoe>
check out (format t "~&~v@{ ~}foo" 3 'foo) !
<phoe>
it prints the spaces normally
<hineios>
yes.
<phoe>
even though the 'FOO argument is obviously not used
<phoe>
smells like a bug to me
<hineios>
if I provide the space as an argument it also prints correctly.
<phoe>
hmmm
<phoe>
maybe it has to do with ~@
<hineios>
I thought so at first, but when both ACL and SBCL have the same behavior.... maybe it is some weird edge case?
<_death>
it looks ok to me
<_death>
the @ modifier for ~{ means the rest of the arguments are used
<hineios>
Ah! yes, I see it now!
<_death>
in the second form this list is empty
<contrapunctus>
Uhm...what's going on here? `(uiop:directory-files (uiop:getcwd))` shows that there's a .ASD file in the current directory. But `(load "file.asd")` says the file doesn't exist :(
<hineios>
thanks _death!
<jasom>
contrapunctus: getcwd is not necessarily the same as default-pathname maybe?
<phoe>
contrapunctus: *default-pathname-defaults*
<jasom>
also you should probably use load-asd for loading asd files; most of the time it doesn't matter, but when it does, it will save you some confusion
<contrapunctus>
jasom, phoe: oh...so why doesn't `uiop:chdir` not modify that variable? 🤔
<jasom>
contrapunctus: uiop:chdir will change the operationg systems current directory, which matters when you run external commands. That is different from changing the default load path for loading files.
* contrapunctus
reads about what determines the value of *default-pathname-defaults*
jeosol has joined #lisp
ghard has quit [Ping timeout: 240 seconds]
<jasom>
similarly, the following won't necessarily return "/" since the *default-pathname-defaults* may not affect the current working directory: (let ((*default-pathname-defaults* #p"/")) (uiop:run-program "pwd" :output :string))
<jasom>
The main confusion is probably that at startup time, *default-pathname-defaults* is set to the current working directory on most implementations.
orivej has joined #lisp
lisp-machine has quit [Quit: Leaving]
dbotton has joined #lisp
<contrapunctus>
Ah, I see. I was basically trying to load my system without typing out `(ql:quickload ...)` for every dependency...sounds like I wanted `asdf:load-system`
<contrapunctus>
Thanks 🙂
matijja has quit [Ping timeout: 264 seconds]
ghard has joined #lisp
<hineios>
_death actually I haven't seen it yet... as I understand it now, the problem is that the iteration provided by the `@` as zero elements, right? meaning that there will be no iterations. but shouldn't the `v` directive force the iteration to occur `v` times?
<hineios>
"at most"!
<hineios>
not "at least"....
<hineios>
ok, I see my error now, sorry for the monologue.
jeosol has quit [Quit: Connection closed]
<phoe>
"Also, if a prefix parameter n is given, then there will be at most n repetitions of processing of str."
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
<phoe>
zero is <= than n
<phoe>
and you have zero elements in your list
IPmonger has joined #lisp
<phoe>
so you will iterate zero times
<phoe>
I also see it now
<hineios>
Exactly!
ghard has quit [Ping timeout: 260 seconds]
skapate has joined #lisp
* Nilby
refrains from pasting a format joke
Wezl has quit [Ping timeout: 260 seconds]
akoana has joined #lisp
skapata has quit [Ping timeout: 272 seconds]
skapate is now known as skapata
ikrabbe has joined #lisp
madage has quit [Remote host closed the connection]
madage has joined #lisp
pankajsg has joined #lisp
jeosol has joined #lisp
ghard has joined #lisp
karlosz has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
aeth has joined #lisp
contrapunctus has joined #lisp
equwal has quit [Ping timeout: 256 seconds]
matijja has joined #lisp
aartaka has quit [Ping timeout: 264 seconds]
jeosol has quit [Quit: Connection closed]
jeosol has joined #lisp
Nilby has quit [Ping timeout: 264 seconds]
Christ0pher has joined #lisp
matijja has quit [Quit: bye]
matijja has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
joethecodhr has joined #lisp
<Josh_2>
With regards to the hyperspec license would using iframes with direct links to the relevant pages constitute a violation of the license?
<Josh_2>
Perhaps they could be used so that the content doesn't have to be rewritten but it would make it possible for someone to add annotations or more code examples
h4ck3r9696 has quit [Quit: Leaving.]
dhil has quit [Ping timeout: 246 seconds]
pankajsg has quit [Read error: Connection reset by peer]
<recalloc>
Assuming fukamachi prioritizes speed, he'll likely decline the PR
joethecodhr has joined #lisp
hjudt has quit [Ping timeout: 272 seconds]
<pyc>
Where does slime-describe-symbol (C-d C-d C-d) fetch symbol documentation from? It does not seem to be CLHS. What is it then?
<Bike>
looks like that calls swank:describe-symbol, which just calls describe
<Bike>
which your implementation probably uses cl:documentation for
attila_lendvai_ has quit [Ping timeout: 256 seconds]
<Josh_2>
recalloc: looks like we need a new library that includes Babels encoder and Trivial UTF's decoder :P
ukari has quit [Remote host closed the connection]
<recalloc>
Josh_2: I'm unironically tempted to pull trivial's decoder over to babel. Gotta look at the licenses, though
ukari has joined #lisp
<recalloc>
Babel's license is MIT. Trivial's is Zlib. Hmm...
<recalloc>
Ultimately making a third coding library would mean that many projects would invariably depend on three projects, which would make things worse than I intended
jeosol has quit [Quit: Connection closed]
Josh_2 has quit [Ping timeout: 264 seconds]
jeosol has joined #lisp
ghard has quit [Ping timeout: 264 seconds]
rgherdt has joined #lisp
rogersm has quit [Quit: Leaving...]
kpoeck has joined #lisp
varjag has joined #lisp
ikrabbe|2 has joined #lisp
ghard has joined #lisp
ikrabbe has quit [Ping timeout: 264 seconds]
ghard has quit [Ping timeout: 260 seconds]
villanella has quit [Remote host closed the connection]
<mfiano>
Hey all, could someone help me out with some array indexing nonsense?
<recalloc>
I can give it a shot
<recalloc>
No promises, though! :)
<mfiano>
I have this constant form that repeats 24 array's of size 2 2048 times. in the comment below, i want to convert it to a flat array of 48 numbers, with the same sequencing...i did something wrong though https://gist.github.com/mfiano/61ae5389285100056c136c8575d34ff4
<mfiano>
comparing with #'mismatch says they are off at position 26
<mfiano>
(after flattening the old version of course)
<recalloc>
And I'm assuming the old array looks like #2A((13.031 98.982) (38.205 92.237)) and so on, right?
<mfiano>
No, it's not a 2d array. its a vector of vectors
<mfiano>
well the lexical variable is anyway. the result of that constant is a flat array of vectors
<recalloc>
ohh ok, so #(#(a b) #(c d)...)
<mfiano>
yes
<mfiano>
I want the new version to be #(a b c d)
<mfiano>
What I have does infact produce all 4096 elements, but they differ at position 26
Cymew has quit [Ping timeout: 256 seconds]
ikrabbe|2 is now known as ikrabbe
<dim>
mfiano: you're doing a single aref call on the array-of-arrays, so you get an array as a result, right?
<_death>
don't you want (* 2 i) and (* 2 (1+ i)) ?
<mfiano>
I did that for another module of this project, but couldn't figure it out for this one
<mfiano>
Maybe I can now...will retry
anticrisis has joined #lisp
<_death>
well, 4096 is not a divisor of 48, so may not be so pretty
<contrapunctus>
I'm making a CGI script. Compiling an executable and copying it to the server isn't much fun and I was advised to set up a remote Lisp setup, which I have. How do I load my system there, though? 🤔 Is there a better way than shuffling files between the local and the remote machine?
<mfiano>
Ah, yeah
ghard has quit [Ping timeout: 264 seconds]
<_death>
I meant 48 not a divisor of 4096.. guess it's not the best time to talk technical matters ;)
<mfiano>
Yes I understood what you meant. Do you think I should make it better with replace somehow, and do you have any pointers?
<_death>
mfiano: I think what you have is fine
<mfiano>
I admit, I've been at this way too long today, and I should be ready for bed soon :)
<mfiano>
Ok, thanks for the suggestions!
hjudt has joined #lisp
<mfiano>
_death: I may need to pick your brain for the next part if you don't mind
<mfiano>
This is the old version that utilizes the unflattened array
<mfiano>
I need to figure out how to do that with the new version
<mfiano>
ALl this nonsense because it is too slow so I want perm-grad to be a specialized array :)
ghard has joined #lisp
kpoeck has quit [Ping timeout: 240 seconds]
h4ck3r9696 has quit [Quit: Leaving.]
ghard has quit [Ping timeout: 260 seconds]
ghard has joined #lisp
<_death>
well, I guess you keep source the same and (truncate x 2) when accessing it.. the rest becomes 4096 and (* 2 x) and (1+ (* 2 x)) .. the returned arrays will different so it's a breaking change
<_death>
then you can probably simplify it further
<mfiano>
hmmm
Nilby has joined #lisp
<_death>
there's a typo in the comment, it should say 0 and 2^32
<mfiano>
it's actually not
kenran has joined #lisp
<mfiano>
the nil means non-inclusive, so it's between 0 and 2^32-2, inclusive (i think)
kenran has quit [Client Quit]
<_death>
well, it's likely not 1-2*32 ;)
ghard has quit [Ping timeout: 264 seconds]
<mfiano>
oh imade that edit like 10 minutes ago if you refresh
<_death>
also, you may use ash instead of expt/truncate
<mfiano>
where am i using expt?
<_death>
(1- (expt 2 32))
<mfiano>
besides the upper bound of the rng
<_death>
:)
<mfiano>
oh right
h4ck3r9696 has joined #lisp
<mfiano>
i'd still have to #'1- it.
<_death>
yeah.. I don't mind expt, ash, u32-max, or #xFFFFFFFF ;)
<mfiano>
(= (1- (expt 2 32)) (1- (ash 2 31))) ; T
<_death>
(ash 1 32)
<mfiano>
that would be double what i want :)
<_death>
well, (= (ash 1 32) (ash 2 31))
<mfiano>
still off by 1 error from 1- with expt though
judson_ has joined #lisp
<mfiano>
_death: trying to make sense about what you said above
<fitzsim>
this is using SBCL as the underlying Lisp
random-nick has quit [Ping timeout: 264 seconds]
amb007 has joined #lisp
<fitzsim>
shouldn't the cl-asdf build default to putting output somewhere user-controlled, like /run/user/${UID} ?
<fitzsim>
if I run the same script as root, it's fine, presumably because root can write under /usr/share
nij has quit [Ping timeout: 260 seconds]
VincentVega has joined #lisp
<fitzsim>
ah, I just figured it out: ~/.config/common-lisp/asdf-output-translations.conf.d/99-disable-cache.conf
<fitzsim>
that had :disable-cache
<fitzsim>
if I comment that out, the script works as the unprivileged user
ghard has joined #lisp
VincentVega has quit [Quit: Connection closed]
sjl has quit [Ping timeout: 264 seconds]
orivej has quit [Ping timeout: 256 seconds]
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
akoana has left #lisp ["Leaving"]
ghard has quit [Ping timeout: 264 seconds]
galex-713 has joined #lisp
ghard has joined #lisp
jeosol has quit [Quit: Connection closed]
<mfiano>
anybody use the additional keywords in uiop:define-package before? i am having a hard time trying to figure out the right combination to get what i want
ghard has quit [Ping timeout: 260 seconds]
pve has quit [Quit: leaving]
jonatack has quit [Ping timeout: 264 seconds]
<mfiano>
Ah I needed (:mix #:a #:b #:cl) (:reexport #:a #:b). I wanted to bring in A and B which shadow some CL symbols, but not RE-EXPORT all CL symbols, so :MIX-REEXPORT was out of the question. This seems to do the trick, albeit a little hacky