rumbler31 has quit [Remote host closed the connection]
nij has joined #lisp
rumbler31 has joined #lisp
Codaraxis_ has quit [Ping timeout: 240 seconds]
gitgood has quit [Ping timeout: 246 seconds]
mathrick has quit [Ping timeout: 252 seconds]
gzj has joined #lisp
GZJ0X_ has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
hendursa1 has quit [Quit: hendursa1]
Codaraxis_ has joined #lisp
hendursaga has joined #lisp
sebboh has quit [Ping timeout: 245 seconds]
nij has quit [Quit: ERC (IRC client for Emacs 27.2)]
Codaraxis__ has quit [Ping timeout: 240 seconds]
skapata has quit [Remote host closed the connection]
Alfr has quit [Quit: Leaving]
mathrick has joined #lisp
nicktick has joined #lisp
xsperry has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
kopiyka has quit [Remote host closed the connection]
kopiyka has joined #lisp
mindCrime has joined #lisp
sebboh has joined #lisp
spaethnl has joined #lisp
Alfr has joined #lisp
elflng has quit [Ping timeout: 268 seconds]
sm2n has quit [Quit: Leaving]
sm2n has joined #lisp
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
rumbler31 has quit [Remote host closed the connection]
krid has quit [Ping timeout: 245 seconds]
semz has quit [Ping timeout: 245 seconds]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
akoana has left #lisp ["Leaving"]
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Josh_2 has quit [Remote host closed the connection]
wxie has joined #lisp
ikrabbe|2 has joined #lisp
ikrabbe has quit [Ping timeout: 246 seconds]
aindilis has quit [Remote host closed the connection]
aindilis` has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
Nilby has quit [Ping timeout: 245 seconds]
nij has joined #lisp
remby has joined #lisp
aindilis` has quit [Remote host closed the connection]
DHARMAKAYA has joined #lisp
gzj has quit [Ping timeout: 252 seconds]
raeda has quit [Remote host closed the connection]
raeda has joined #lisp
matty has joined #lisp
matty has quit [Read error: Connection reset by peer]
thinkpad has quit [Ping timeout: 246 seconds]
thinkpad has joined #lisp
frost-lab has joined #lisp
voidlily has quit [Ping timeout: 258 seconds]
refusenick has joined #lisp
voidlily has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 252 seconds]
Alfr is now known as Guest1339
Alfr has joined #lisp
<beach>
Good morning everyone!
Guest1339 has quit [Ping timeout: 245 seconds]
<remby>
morning!
luis9 has joined #lisp
luis has quit [Ping timeout: 252 seconds]
luis9 is now known as luis
davros has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
semz has quit [Ping timeout: 250 seconds]
thinkpad has quit [Read error: Connection reset by peer]
elflng has joined #lisp
thinkpad has joined #lisp
mrchampion has quit [Ping timeout: 265 seconds]
mrchampion has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
thinkpad has quit [Read error: Connection reset by peer]
greaser|q has quit [Changing host]
greaser|q has joined #lisp
greaser|q is now known as GreaseMonkey
thinkpad has joined #lisp
anewuser has joined #lisp
<refusenick>
I have someone asking me to make them a website (a homepage/blog), and I'd like to give Lisp a shot (instead of LAMP)
<beach>
Good idea.
<refusenick>
It's going to be atop a VPS (probably a DigitalOcean droplet), and they'd like to be able to edit the content (blog posts, CV updates) in a GUI format, as if it were Wordpress
anewuser has quit [Remote host closed the connection]
anewuser has joined #lisp
Nilby has joined #lisp
<refusenick>
There was a "Lisp apps on GCE" Medium post which made it to the top of HN a few days ago, and which looks like a decent starting point (although, with limited RAM and storage, I'd like to ideally drop Nginx and PostgresSQL to instead do everything inside the Lisp image)
<refusenick>
They're using Windows, I'm using Linux. What's a cross-platform way to get them a graphical rich text editor which can connect to and live update the running Lisp image in a relatively secure fashion?
thinkpad has quit [Read error: Connection reset by peer]
sbodin has joined #lisp
sbodin has left #lisp [#lisp]
<refusenick>
Could I serve them an in-browser rich text editor (Lisp running via Wasm) which opens a Swank connection to the server when they log in?
thinkpad has joined #lisp
<refusenick>
Parenscript would probably be a better bet?
<no-defun-allowed>
The first part is to get Lisp on WASM.
<refusenick>
no-defun-allowed: Does it still have stack manipulation issues?
<refusenick>
Wasn't it multiple return which proved problematic?
<no-defun-allowed>
Not sure, but you also have to deal with garbage collection and non-local transfer of control.
<no-defun-allowed>
Though you could do Parenscript now, sure.
anewuser has quit [Remote host closed the connection]
anewuser has joined #lisp
<refusenick>
I imagine it'd be easier to make them a desktop app?
anewuser has quit [Remote host closed the connection]
<refusenick>
What GUI framework works best? McClim?
<refusenick>
Maybe give them Markdown and a preview button?
<refusenick>
Replicating Word or Wordpress would be hard
<remby>
Word or Wordpress? those seem different
Bike has quit [Quit: Lost terminal]
<moon-child>
presumably both provide wysiwyg rich text editors
srhm has quit [Quit: Konversation terminated!]
<remby>
oh I see
<remby>
I think a basic "rich text" editor would not be bad that's pretty much just images, bold, italics, bullet points and centering
<remby>
could do it with html :P
hypercube has quit [Ping timeout: 252 seconds]
waleee-cl has joined #lisp
abhixec has joined #lisp
wxie has quit [Quit: wxie]
<splittist>
refusenick: isn't the normal way just embedding a standard js editor widget (TinyMCE, whatever) in the page and handling the AJAX (or whatever the kool kids do now) in the lisp webserver to update the model?
<refusenick>
splittist: I'm not much of a web programmer, like, at all
tempest_nox has quit [Remote host closed the connection]
<splittist>
refusenick: in particular, Part 6 integrates CodeMirror, a web editor thingy
gaqwas has quit [Ping timeout: 268 seconds]
andrei-n has joined #lisp
antaoiseach has joined #lisp
antaoiseach has quit [Client Quit]
Codaraxis__ has joined #lisp
stylewarning has quit [Ping timeout: 245 seconds]
Codaraxis_ has quit [Remote host closed the connection]
parisienne has quit [Ping timeout: 245 seconds]
stylewarning has joined #lisp
stylewarning has joined #lisp
parisienne has joined #lisp
cyberlard has quit [Ping timeout: 245 seconds]
rme has quit [Ping timeout: 245 seconds]
rme has joined #lisp
cyberlard has joined #lisp
Alfr has quit [Killed (egan.freenode.net (Nickname regained by services))]
crypto_ has joined #lisp
Alfr has joined #lisp
z0d has quit [Ping timeout: 245 seconds]
alanz has quit [Ping timeout: 245 seconds]
jackhill has quit [Ping timeout: 245 seconds]
jackhill has joined #lisp
Nilby has quit [Ping timeout: 245 seconds]
kopiyka has quit [Ping timeout: 245 seconds]
bytesighs has quit [Ping timeout: 245 seconds]
kopiyka has joined #lisp
alanz has joined #lisp
stylewarning has quit [Ping timeout: 245 seconds]
igemnace has quit [Ping timeout: 245 seconds]
igemnace has joined #lisp
bytesighs has joined #lisp
stylewarning has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<raeda>
What's the motivation for having APPLY unpack the last item in the rest list?
<jackdaniel>
raeda: to complement funcall which doesn't do that
<jackdaniel>
i.e you may want to add some new arguments to existing list
<jackdaniel>
(apply 'make-pane :frame fm (list* :port port args))
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
<jackdaniel>
well, that wasn't a good example because you could lift the port argument out of the last argument
<jackdaniel>
but, say (progn (remf args :foo) (apply 'make-pane :frame fm args))
<raeda>
That's neat. So you could do some Currying by adding arguments to the front of the arg list
<jackdaniel>
yes, that's one of its uses
orivej has quit [Ping timeout: 252 seconds]
<moon-child>
I have the opposite question: why is cons not variadic?
<moon-child>
with e.g. (cons a b c d) ←→ (cons a (cons b (cons c d)))
contrapunctus has joined #lisp
shka_ has joined #lisp
<jackdaniel>
moon-child: because list* serves this purpose
thinkpad has quit [Ping timeout: 240 seconds]
<jackdaniel>
cons is a constructor for a type cons
<jackdaniel>
list* is used to construct lists as you have described (i.e improper lists)
thinkpad has joined #lisp
daphnis has joined #lisp
daphnis has quit [Client Quit]
b20n has quit [Ping timeout: 245 seconds]
pent has quit [Ping timeout: 245 seconds]
karlosz_ has joined #lisp
b20n has joined #lisp
pent has joined #lisp
daphnis has joined #lisp
<refusenick>
Well, this is a little embarrasing...
karlosz has quit [Ping timeout: 245 seconds]
karlosz_ is now known as karlosz
<refusenick>
I tried launching Sly for the first time in a while
<daphnis>
is there a way to find the number of arguments desired by a given function?
<refusenick>
And it no longer works
stylewarning has quit [Ping timeout: 245 seconds]
narimiran has quit [Ping timeout: 245 seconds]
<refusenick>
Apparently, Slynk no longer compiles due to the removal of %SIMPLE-FUN-NEXT from sb-kernel
<jackdaniel>
daphnis: there is no way guaranteed by the standard
<jackdaniel>
but you may try (swank::arglist #'list)
<jackdaniel>
there is also library, I think trivial-arguments or trivial-argument-list
stylewarning has joined #lisp
<jackdaniel>
refusenick: maybe sly also updated?
kopiyka has quit [Ping timeout: 245 seconds]
<jackdaniel>
to match sbcl shifting its internal structures
<daphnis>
jackdaniel: thanks!
glamas has quit [Ping timeout: 245 seconds]
<jackdaniel>
sure ,)
<jackdaniel>
mind that if you do silly things, like setting (debug 0) then possibly you won't be able to see the arglist
b20n has quit [Ping timeout: 245 seconds]
glamas has joined #lisp
narimiran has joined #lisp
<refusenick>
Ah, yep
b20n has joined #lisp
rogersm has joined #lisp
<refusenick>
I thought I had things set so C-x C-e on (use-package sly ...) would pull and rebuild it if the HEAD tag was outdated
<refusenick>
but clearly I was wrong!
remby has quit [Quit: Going offline, see ya! (www.adiirc.com)]
scymtym_ has quit [Remote host closed the connection]
lottaquestions has quit [Remote host closed the connection]
lottaquestions has joined #lisp
karlosz has quit [Quit: karlosz]
thomasb06 has joined #lisp
<thomasb06>
jackdaniel how was your beer?
<jackdaniel>
as good as usual, thanks
<thomasb06>
(hehe)
hypercube has quit [Quit: WeeChat 3.1]
attila_lendvai has quit [Ping timeout: 246 seconds]
wxie has joined #lisp
Codaraxis__ has quit [Ping timeout: 246 seconds]
daphnis_ has joined #lisp
Krystof has joined #lisp
fourier has joined #lisp
daphnis has quit [Ping timeout: 260 seconds]
crypto_ is now known as z0d
<thomasb06>
jackdaniel how did you learn Lisp? Lately, I'm trying to learn some
<jackdaniel>
it is not a very interesting story. I've started a scientific club at my uni around the artificial intelligence and I've found that Lisp is a all the jazz for AI (quite outdated information even then)
<jackdaniel>
so I've made a "course" at our meetings based on pcl
srandon111 has quit [Read error: Connection reset by peer]
<jackdaniel>
then in my first job I was working with embedded systems and I was using ecl, so I took its maintainership since it wasn't maintained
fourier has quit [Changing host]
fourier has joined #lisp
<jackdaniel>
after that I've achieved nirvana and I'm beyond ego, one with the true nature of lisp, floating above the sky surrounded by the singing parenthesis
<thomasb06>
ok, you're a professional then. It's from Emacs I discovered Lisp and trying to go a bit further
<thomasb06>
not sure it would have a professional outcome
<thomasb06>
there's a window manager in Lisp that looks nice, Ulubis. But it doesn't handle Nvidia cards, maybe I could have a look
voidlily has quit [Ping timeout: 250 seconds]
<jackdaniel>
if you make money from it you are a professional, if you don't then you are not (I think that's the distinction); it has little to do with skill
<moon-child>
why does a window manager care what GPU you run?
hypercube has joined #lisp
hypercube has quit [Client Quit]
<MichaelRaskin>
Because Wayland
<moon-child>
jackdaniel: surely it requires a certain degree of skill in a field that you're worth being paid to perform it?
<thomasb06>
exactly
<MichaelRaskin>
I would expect it to run fine with Nouveau driver, though
<thomasb06>
(exactly: Wayland)
<jackdaniel>
moon-child: I know a few professionals (not necessarily related to lisp) who learned to type code and stopped at that
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
<jackdaniel>
and there are a lot of amateour programmers with very deep knowledge; so that's it. but this is offtopic I think
DHARMAKAYA has joined #lisp
<thomasb06>
MichaelRaskin next week-end I'll retry but few weeks ago, the wm crashed at startup. And my driver is nouveau
hypercube has joined #lisp
hypercube has quit [Client Quit]
<thomasb06>
jackdaniel an amateur skilled programmer, that would be great already
<MichaelRaskin>
Hm, unfortunate, thanks for the information
<jackdaniel>
as I said, these qualities are orthogonal. of course it is nice to be paid when you are skillful at something
pve has joined #lisp
<thomasb06>
MichaelRaskin the author answered on GitHub apparently it comes the fact Nvidia doesn't comply to Gdm or a name like that
<MichaelRaskin>
GBM, I would expect
<thomasb06>
most probably... Something to do with graphics cards
<MichaelRaskin>
But I thought it was more of a problem with their proptietary driver and Nouveau was at least a bit closer to the rest of the ecosystem
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
daphnis has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
monolithic has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
wxie has quit [Remote host closed the connection]
nicktick has quit [Ping timeout: 240 seconds]
fengshaun_ has quit [Ping timeout: 246 seconds]
narimiran has quit [Ping timeout: 252 seconds]
ikrabbe|2 has quit [Ping timeout: 265 seconds]
fengshaun has joined #lisp
zefram22 has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 260 seconds]
__jrjsmrtn__ has joined #lisp
Nilby has joined #lisp
<nij>
I understand MOP as an extension of CLOS. However, what would be on top of MOP that extends MOP again? (Or it's not needed, yet?)
<jackdaniel>
mop is not an extension of clos, mop is a generalization of clos
<jackdaniel>
that allows you to write clos-like object oriented systems
<jackdaniel>
(in other words, it is a machinery to write clos extensions)
<nij>
Oh.. that's a better term. Thanks jackdaniel.
<no-defun-allowed>
If we are to talk about CLOS and the MOP as separate, I would say that MOP is used to implement CLOS, but you use CLOS stuff (classes, methods) to implement new object systems with the MOP.
* nij
is confused.
<nij>
MOP is used to implement CLOS.
<nij>
What is used to implement MOP? Is it CLOS?
<no-defun-allowed>
The introductory half of the Art of the Metaobject Protocol (the book which introduced the MOP, as I understand it) introduces it as a CLOS program. But implementation strategies can vary.
* nij
gasps.
<nij>
So CLOS is full enough to describe its "meta", which can be in turn used to define CLOS itself?
nostoi has quit [Quit: Verlassend]
<no-defun-allowed>
The authors present Closette, which builds up from structure classes (see <https://github.com/binghe/closette/> which sadly does not seem to include the "Closette is a Knights of the Lambda Calculus production." announcement upon loading).
<nij>
I sense a circularity between CLOS and MOP.. did I miss something?
<no-defun-allowed>
SICL bootstrapping instead uses multiple environments to gradually step from the host object representation to its own object representation, and that uses the meta-object protocol to my knowledge. But I don't have a good answer for what CLOS alone can do.
<no-defun-allowed>
The first half of the book guides you through implementing the MOP and CLOS in CLOS alone.
<jackdaniel>
the 'usual' implementaiton strategy is to provide stubs that are normal functions and object prototypes and then gradually replace them
<nij>
:-O
wxie has joined #lisp
<no-defun-allowed>
But recall that you can bootstrap from DEFSTRUCT as you please, and you can create DEFSTRUCT with lists, and lists with closures, so on and so forth.
<nij>
Lists can be also defined with cons. :-O
<no-defun-allowed>
But yes, a CLOS implementation supporting the MOP builds CLOS from the MOP, but also MOP from CLOS.
andrei-n has quit [Read error: Connection reset by peer]
zefram22 has quit [Read error: Connection reset by peer]
zefram22 has joined #lisp
kopiyka has joined #lisp
<nij>
If I have a function #'f, defined by (defun f (x) (g x)), that calls another function #'g, which could possibly call other functions and the environment, can I ask lisp to return a "closure" of f for me?
<nij>
So the returned object should remember everything that's linked to f, and should be able to reproduce #'f at the moment I ask for the closure.
wxie has quit [Quit: wxie]
kopiyka has quit [Ping timeout: 245 seconds]
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
<nij>
no-defun-allowed: Oh indeed, in TAOTMP.. it says "The heart of the matter is that the introduction of metaobject protocols makes CLOS
<nij>
into a procedurally reflective language [Smith 84]..". There is a metacircular issue there. And CLOS is in some sense full itself (i.e. it can be used to define MOP).
wxie has joined #lisp
<nij>
It's pretty similar to when mathematicians want to define a set, but they use sets to define models, which are in turn used to justify if a class is a set.
zefram22_ has joined #lisp
andrei_n has quit [Read error: Connection reset by peer]
orivej has joined #lisp
zefram22 has quit [Read error: Connection reset by peer]
zefram22 has joined #lisp
vegansbane6963 has joined #lisp
ebrasca has joined #lisp
ebrasca has quit [Ping timeout: 246 seconds]
ebrasca has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aartaka_d has quit [Read error: Connection reset by peer]
<heisig>
The schedule is not yet final, but I hope it is still interesting. In particular, it reveals what our keynote speakers will present.
<jackdaniel>
heisig: thanks!
yitzi has quit [Quit: yitzi]
zefram22 has quit [Quit: zefram22]
zefram22 has joined #lisp
<luis>
heisig: cool stuff
orivej has quit [Ping timeout: 245 seconds]
skapata has joined #lisp
<nij>
thanks <3 heisig
<nij>
kopiyka has joined #lisp
<beach>
heisig: Looks great so far!
kopiyka has quit [Ping timeout: 245 seconds]
<flip214>
If it's a virtual event, aren't all talks (potential) keynotes? Just depends in which order they're listened to (by each individual participant), right?
<jackdaniel>
I think that a keynote sticker is meant to signify the talk as "highlighted"
yitzi has joined #lisp
<heisig>
flip214: The main difference is that keynote speakers are invited, while other speakers have to submit a high-quality paper to be allowed to present.
amb007 has quit [Read error: Connection reset by peer]
<heisig>
Of course we try to invite very interesting people, so there is a good chance that these talks will be highlights of the symposium.
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
igemnace has quit [Quit: WeeChat 3.1]
amb007 has quit [Read error: Connection reset by peer]
<jcowan>
In addition, keynotes tend to be ephemeral, unless someone transcribes them. If you miss a talk you can read the paper; if you miss a keynote you are SOL.
amb007 has joined #lisp
rodriga has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
nopf has quit [Quit: Lost terminal]
kopiyka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
amb007 has joined #lisp
aartaka_d has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
aartaka has quit [Ping timeout: 252 seconds]
narimiran has joined #lisp
krid has joined #lisp
Nilby has quit [Ping timeout: 250 seconds]
zefram22_ has quit [Quit: zefram22_]
zefram22_ has joined #lisp
layerex has joined #lisp
layerex has quit [Remote host closed the connection]
layerex has joined #lisp
<thomasb06>
the super league raw is over?
aartaka has joined #lisp
klltkr has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
<splittist>
heisig: 'Cyber' or 'Cyper' in Keynote 3?
OlCe has joined #lisp
mrchampion has quit [Ping timeout: 240 seconds]
paul0 has quit [Ping timeout: 260 seconds]
mrchampion has joined #lisp
Bike has joined #lisp
wsinatra has joined #lisp
zefram22__ has joined #lisp
random-nick has joined #lisp
zefram22_ has quit [Ping timeout: 245 seconds]
nature has joined #lisp
zefram22 has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
<MrtnDk[m]>
What is Cyper, splittist ?
<flip214>
a typo, I guess
krid has quit [Remote host closed the connection]
layerex has quit [Quit: Leaving]
thinkpad has quit [Ping timeout: 260 seconds]
daphnis has quit [Ping timeout: 240 seconds]
daphnis has joined #lisp
matty has joined #lisp
matty is now known as mister_ms_spooky
mister_ms_spooky is now known as mister_m^2
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
paul0 has joined #lisp
loke has quit [Remote host closed the connection]
rogersm has quit [Quit: Leaving...]
loke has joined #lisp
<splittist>
yes (or 'typos')
daphnis has quit [Ping timeout: 252 seconds]
daphnis has joined #lisp
<flip214>
(or T '|splittist|:|typos|)
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
mrchampion has quit [Ping timeout: 245 seconds]
thinkpad has joined #lisp
zefram22 has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
zaquest has quit [Quit: Leaving]
srhm has joined #lisp
curtosis has joined #lisp
cranium_ has joined #lisp
mrchampion has joined #lisp
frost-lab has quit [Quit: Connection closed]
orivej has quit [Ping timeout: 252 seconds]
nicktick has joined #lisp
orivej has joined #lisp
rumbler31 has joined #lisp
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
zaquest has joined #lisp
Sheilong has joined #lisp
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
Josh_2 has joined #lisp
<Josh_2>
Stupid question time. How do I get the directories within a directory?
rumbler31 has quit [Remote host closed the connection]
cage_ has joined #lisp
<Xach>
Josh_2: one way is to list everything and consider everything without a pathname-name and pathname-type to be a directory. but it is not foolproof.
<Josh_2>
so not trivial then
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
<Josh_2>
I think I will try pathname-utils
orivej has quit [Ping timeout: 240 seconds]
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
<Josh_2>
Turns out it was trivial, uiop:subdirectories
long4mud has quit [Quit: WeeChat 3.0.1]
rodriga has quit [Ping timeout: 240 seconds]
<nature>
I've been drawn to lisp those past few weeks and I started reading PCL but he advised to use emacs and SLIME for the "true" lisp experience, does SLIMV bring the same experience or is it inferior?
orivej has joined #lisp
curtosis has joined #lisp
curtosis is now known as curtosis[away]
curtosis[away] is now known as curtosis
rodriga has joined #lisp
curtosis is now known as curtosis[away]
<nature>
I really can't use emacs (I don't even know how to close it, to give you an idea of my emacs proficiency) but I am a heavy vi user, hence me asking about SLIMV
<beach>
nature: I believe most people here use Emacs+SLIME, but if you are patient, I am sure some SLIMV user will answer you.
<MichaelRaskin>
… or vlime users
<beach>
Or that.
<jcowan>
or slvme users. :-)
curtosis[away] is now known as curtosis
<nature>
haha ok thanks, yeah I am in no rush :D
<nature>
Also on a more generic note, a question only experience can answer, how maintainable is CL?
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
<nature>
I've read quite a bit about the fact that running decades old code is a breeze, it seems too good to be true for someone how wan't even able to build a node project that was unmaintained for 6 months...
<beach>
nature: You mean code written in Common Lisp? That depends a lot on the experience of the person who wrote it.
pve_ has joined #lisp
<MichaelRaskin>
Much less churn caused by upstream updates, which is great.
srandon111 has joined #lisp
<nature>
Yes Common Lisp, so if I start writing lisp tomorrow my code will probably be a sore to the eye right?
<beach>
nature: Right, it won't stop working for no particular reason. But whether it can be improved or extended depends on the way it was written in the first place. But that's no different from other languages.
<beach>
nature: Oh, yes! :) And you will notice it yourself next year if you look back on it.
<beach>
nature: But we can help you out to make it more idiomatic.
<nature>
:)
<Odin->
I think it's relevant here that Common Lisp was originally defined with the explicit intent of making sure existing code in various related but different Lisp implementations could run with the minimum of alterations.
pve has quit [Ping timeout: 260 seconds]
<MichaelRaskin>
… and of course, if the goal is for the code to be maintainable by _you_, you should not only think in terms of idiomatic, but in terms «how to make the logic of the code compatible with _my_ thinking about the problem in a year?»
<beach>
Right, I assumed that "maintainable" meant that other people could get involved.
<Odin->
That makes for features that sharply lessen the risk of 'legacy code' being impossible to run, which is somewhat distinct from how maintainable said code is...
<beach>
... and that assumption could be wrong of course.
<nature>
That's so interesting, I recently read about the importance of "authenticity" in software programming, it seems to be quite the thing in Lisp.
<beach>
nature: What does the term mean?
<MichaelRaskin>
Also the situation of other people getting involved by working tightly together with you on the code is different from other people having to maintain it, hm, reverse-cold-turkey
<nature>
beach: Looking into Lisp for hobby programming :)
<easye>
nature: "authenticity"? Link? [17:12]
<MichaelRaskin>
(… and the situation beach optimises for is more or less sudden immersion into the code by a different experienced Common Lisp programmer who is actually Common Lisp-first programmer — which is unlikely to ever happen in practice unless you are at Ravenpack or so)
<nature>
beach: Authenticity: n.The quality or condition of being authentic, trustworthy, or genuine.
<easye>
MichaelRaskin: heh, there seems to be a number of companies other than RavenPack doing CL now. HRL is interesting.
<Odin->
nature: That's just moving the question. :p
<easye>
nature: yeah, technical foul.
<beach>
nature: Here is a thing, though, to put what MichaelRaskin said into some perspective. What often happens here is that some newbie decides that nobody else will have to look at the code.
<beach>
But then, that newbie has a problem and submits the code for #lisp participants to read. Then, the first thing that happens is that the newbie is told that the code is incomprehensible to Common Lisp programmers, and it needs to be improved before help can be had.
<nature>
hahaha, I guess it's basically like someone who crafts furniture, he can be authentic or not, I mean it's hard to explain ^^'
orivej has quit [Ping timeout: 246 seconds]
<beach>
nature: I think I know the usual English meaning of the term. I just couldn't figure out what it meant in the context of programming.
<MichaelRaskin>
Hm yeah, HRL might be large enough
<easye>
nature: I thought you were referring to some specific piece of text wrt. authenticity in programming. It's an interesting precis; I'd like to see the exposition.
<beach>
Me too.
<Odin->
nature: Well, I don't think there's any programming language community that values inauthenticity in any sense; it's probably more a question of what is meant by 'being authentic' in each.
<easye>
HRL is where stylewarning ended up methinks. Another quilc/qvm group!
<nature>
Basically it was on some imageboard someone asked about the purpose (philosophical) of programming and someone made a lengthy answer about the importance of authenticity, I found it really inspiring
<MichaelRaskin>
Odin-: I would expect some subset of Java community to value inauthencity…
<easye>
MichaelRaskin: Oh, come on. Leave the poor Java people alone.
<easye>
At least they are evolving.
<nature>
I think Golang is also quite like that
<easye>
;)
<Odin->
MichaelRaskin: See, while I genuinely thought of making that joke, I don't think it's really representative of reality. :p
<MichaelRaskin>
Odin-: well, communication messed-up beyond any repair does happen in some areas of enterprise
<easye>
At least there is abcl for a given Java programmer to pull herself into the light of the lambda...
<beach>
MUBAR
<beach>
We could use it as a new metasyntactic variable.
<Odin->
MichaelRaskin: No question about it. I just don't think that's specific to a programming language, or even programming. :p
<MichaelRaskin>
easye: what about the light of being not prohibited to communicate with anyone having at least third-hand experience with the actual problem being solved?
<jcowan>
IMO the claim that code is incomprehensible is not actually correct: it's more like "it's not quite what we expect, so we aren't going to bother with it."
<MichaelRaskin>
Odin-: I would expect Java to have better tooling ecosystem than most alternatives for shipping something that can at least pretend to work.
<easye>
MichaelRaskin: I'd argue that's a "community" problem.
<easye>
Now, all languages are sorta defined by how they are used and evolved by a community.
<Odin->
jcowan: Most claims of incomprehensibility go like that, in any domain. Most things aren't encrypted.
<beach>
jcowan: Right, or rather "it is going to take more time for me to understand it than I am willing to spend on it".
<jcowan>
Most "bad code" isn't even obfuscated particularly, more like unidiomatic.
<easye>
What's unique to Java, is that it was the first world-historical language to have a community with magnitudes greater of user connected via the interwebs.
<easye>
JavaScript has sorta taken over that role in the last decade.
<easye>
And that "magnitudes-greater" community necessarily has a lot of members who "just don't know better".
<Odin->
easye: Dunno, I can think of at least two earlier programming languages with a seriously bad rap that were both also designed with an intent to broaden the user base for programming.
<Odin->
(COBOL and BASIC.)
<jcowan>
Some very old Lisp code is a direct translation from punch cards, which means it typically has only necessary spaces and is wrapped every 72 characters, creating a wall of text. *That* is obfuscated.
<easye>
Odin-: but--I would argue not knowing which ones you are referring to--those languages didn't have 100x as many people "learning/using" as Java in the 2000s
pve_ has quit [Ping timeout: 240 seconds]
<jcowan>
The idea with Cobol was that managers could read it even if they couldn't write it.
daphnis has quit [Ping timeout: 245 seconds]
<easye>
And able to share and experiment via the intertubes. There is easily 10x as many choices for a given library in Java in anything else other than JavaScript.
<jcowan>
So it was both code and pseudo-codw.
<Odin->
easye: Hm. Good point, though I suspect that the ratio of people just picking up programming vs. experienced programmers was stupid high for Basic in the eighties, even in the code that got published in books and magazines.
<jcowan>
easye: Of which between 9 and 10 are unusable.
* easye
read _Compute's Gazette_. And typed in a lot of those programs.
<Odin->
easye: Don't get me wrong, I'm not trying to say the issue doesn't exist for Java.
<Odin->
But I think there were previous examples, and definitely later ones.
<jcowan>
I can't be quantitative, but I think Perl and Python have large libraries too.
<Odin->
Python also springs to mind.
luckless_ has quit [Remote host closed the connection]
* easye
is kinda ignoring MSFT tooling in his argument. There are a lot of Excel macros with VisualBasic powering trading models...
<Odin->
Perl is another one of those programming languages explicitly designed for use by non-programmers, actually...
<jcowan>
Yes, spreadsheets have a bug density that would make us feel sick if we actually looked at the code.
<cranium_>
re perl: you mean because it's more of a sysadmin thing or...?
<easye>
jcowan: Odin-: I'd have to crunch some stats, but I subjectively find there to be many more choices for a given Java library than Python or Perl.
<easye>
CPAN/setuptools have tended to homogenize solutions.
<cranium_>
as in many more libraries to do a certain thing?
<easye>
cranium_: yeah.
<Odin->
cranium_: Well, because it was specifically designed to be useful for sysadmins, yes.
<easye>
Like look at how many ways there are to deal with JSON in Java vs. another lanauge.
nick3000 has joined #lisp
<jcowan>
As I said, having many libs to do something doesn't tell you which ones are usable
<easye>
jcowan: no argument there. I'm arguing for something like a sociology of programming languages.
<jcowan>
Perl is a language for programmers with a linguistic background. Fortunately for me, I am one of them.
<easye>
Or an anthropology if you are feeling unking.
<cranium_>
Odin-, I asked because sysadmins are not necessarily the people that spring to mind when we talk about "languages for non-programmers".
<easye>
s/unking/unkind/
<nick3000>
Hey I am a CL noob, day to day I do C++. Is there any system for user-defined type coercion? I see a coerce function documented, but it doesn't seem overloadable.
<jcowan>
why unkind? "Sociology is anthropology done on Westerners."
<easye>
jcowan: heh.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<easye>
Very true.
contrapunctus has joined #lisp
<easye>
I'd argue that Java was more "global" then any previous language.
<Bike>
nick3000: it is not overloadable. since lisp doesn't have implicit coercions, it makes more sense to just define coercion functions when they are needed
contrapunctus has left #lisp ["Disconnected: closed"]
<Bike>
well, mostly doesn't have
contrapunctus has joined #lisp
<Odin->
cranium_: No, but at the same time you can hardly deny that there's a substantial gap between sysadmins and programmers in terms of how they think about using computers...
<cranium_>
That is definitely true.
<easye>
It's amazing how many companies in the Valley, China, and India have redone the openjdk8 rather than deal with ORCL 'cuz they need it for their biz.
<nick3000>
Bike: Okay thanks.
<Odin->
easye: I think Java is more visibly so than COBOL used to be.
<MichaelRaskin>
Odin-: you mean sysadmins are forced to have at least some realism?
<jcowan>
Indeed, in experimental psychology much of what we think we know is based on studies with WEIRDos (people from Western, Educated, Industrialized, Rich, Democratic societies).
<easye>
Odin-: I've always considered myself both an admin and a programmer. They tend to reinforce each other, esp. when one deals with embedded development.
<jcowan>
Devops/SRE are designed to bridge that gap
<easye>
jcowan: WEIRDos is an interesting framework. I haven't read the book yet. Worth it?
<Odin->
MichaelRaskin: Well, yes. Sometimes. At other times, they don't need to understand _how_ computers work to the same extent, so take strange routes. I'm not making a value judgement either way.
* easye
read the _NY Review of Books_ and the AstralCodex writeups of WEIRDos.
Lycurgus has joined #lisp
<Josh_2>
bit offtopic
* easye
fears he has frayed the boundaries of #lisp topicality to the breaking point, and will shut up for a whilw.
<Odin->
easye: They wouldn't reinforce each other if they didn't differ to some extent, though. Otherwise they'd just be the same thing twice. :p
<Odin->
Hrm.
<Odin->
Good point.
* Odin-
shuts up.
<nature>
Perfect time for me to come back on topic, do anybody has some experience with SLIMV here? :D Is it similar to SLIME or will I miss some things?
<easye>
nature: you will miss Emacs?
<nature>
I don't even know how to close the thing :/
<jcowan>
http://hci.ucsd.edu/102b/readings/WeirdestPeople.pdf is a very accessible article from Behavior and Brain Sciences, with the added B&BS feature of open peer commentary (which are as twice as long as the article itself) and a final comment by the authors.
<easye>
jcowan: thanks.
<jcowan>
s/commentary/commentaries
<Odin->
nature: I believe some people get by without editor support at all, so I don't think you _have_ to use emacs.
* easye
can't imagine dealing with git without magit.
* Lycurgus
would wanna use SLY but the world drags one back to SLIME
<Odin->
In particular, I don't think learning both how to use emacs and Lisp at the same time is what you'd call a shallow learning curve.
* Lycurgus
suggests the SLY author make XREF easy to compete
<MichaelRaskin>
Odin-: true, I prefer Vim without external plugins for writing code, which sometimes includes thousands of lines of Common Lisp
<nature>
Isn't editor support and the possibility to iterate quickly with SLIME one of the main selling point of Lisp?
<cranium_>
There has been talk about development of an Lisp IDE a few days ago.
<beach>
nature: MichaelRaskin's code is very un-idiomatic looking, so you might want to think twice before emulating him.
<cranium_>
Frankly I think the iterative development thing is one of CL's stronger aspects _despite_ Emacs, though I have basically done none of it.
<beach>
nature: He is a good programmer otherwise, in that his code works well. It is just that he refuses to use the tools that make his code idiomatic-looking.
<Odin->
nature: It's certainly a convenience, yes. But you can do much of the iterative work just through the implementation's REPL, if it comes to that.
mister_m` has joined #lisp
<MichaelRaskin>
beach: to be fair, all tools that would make my code idiomatic looking are integrated with Emacs that I dislike for more than one reason
<nature>
Are there people doing things the "UNIX way" in the Lisp world?
<beach>
MichaelRaskin: I understand. Just stating the facts.
<Odin->
nature: That depends on what you mean by "the UNIX way".
<beach>
nature: SLIME helps with a number of things, such as displaying lambda lists of various operators as you type a form. You would want to make sure your tool can do the same.
<cranium_>
what is meant by "the UNIX way"? Lots of small tools? Pipes? Vim?
<MichaelRaskin>
I will happily use Eclector + pretty printer once there is such a combo usable as formatter
<nature>
mostly pipes and small tools yeah
<beach>
nature: Then no.
<Odin->
nature: What are 'small tools'?
<Odin->
Small binaries that you run from the shell, then no.
<nature>
grep, fmt, vi, etc...
<beach>
nature: Common Lisp is better with small tools that cooperate using the conventions of Common Lisp inside a single Common Lisp image.
<Odin->
Small pieces of code that you run from the REPL, sure.
OlCe has quit [Remote host closed the connection]
<nature>
So the REPL is really the central piece?
<beach>
yes.
<MichaelRaskin>
nature: I sometimes kind of do, but that's when I don't like both Lisp world option and pure-shell option
<MichaelRaskin>
If you want Lisp world, REPL makes infinitely more sense
<cranium_>
nature, I don't think so, as these Unix tools are there to manipulate text ("text is a universal interface"), whereas the idiomatic way in Lisp is to manipulate and express data through Lists (i.e. actual data structures)
<beach>
nature: When you work with Common Lisp, it is most convenient to think of the Common Lisp system as your main environment and to adopt the conventions of that environment.
OlCe has joined #lisp
<Odin->
nature: You're not _that_ far off if you think about the REPL as being analogous to the command shell.
mister_m^2 has quit [Ping timeout: 260 seconds]
<nature>
That makes a lot of sense
<Odin->
nature: Although, as noted here, Lisp doesn't work only with streams of bytes.
<MichaelRaskin>
Have you ever written a thousand-line shell script that would do something useful correctly?
<MichaelRaskin>
If not, there is surely nothing for you in a mixed flow
<beach>
nature: The Unix way, communicating with sequences of bytes, is usually way too primitive for any serious work, which is why Unix applications tend to be huge monoliths. Common Lisp does not have that problem, because communication can be in the form of complex objects.
<cranium_>
Has CL historically (think Lisp machines / OSs) been just one big environment (i.e. one image in modern parliance) that people did all their computing in? Do some people still do that?
<beach>
cranium_: I should hope so.
<nature>
That's really interesting to grasp, I've been quite puzzled lately on how to reconcile both world, when in facts it's actually a bad idea
<beach>
cranium_: The convenience of being able to just pass a pointer to some complex data structure (and preserving its identity), rather than having to serialize it (and losing its identity) is just so great.
<Odin->
cranium_: Lisp originated as a more or less interactive language at a time before time sharing was much of a thing, and I think the assumptions have kinda stuck.
<contrapunctus>
beach: I've been thinking about that, actually...like I was imagining a system where communication between composable applications occurs through structured data rather than text...but then it occurred to me - that's exactly what awk is made for 🤔 of course, I know very little awk and have never done a lot with it...
<Odin->
cranium_: So, yeah, conceptually, that's usually how it's been.
<MichaelRaskin>
For the record, the convenience of being able to enforce copy-able serialisation is also great.
<cranium_>
nature, reading the SHCL github page, its approach seems like a quite natural fit. Have the shell be a CL application and escape to CL at any point.
<beach>
contrapunctus: Structure is not all there is to it though. Like I said, preserving identity is an important aspect too.
<Odin->
nature: I'm not sure I'd go so far as to say it's a 'bad idea', but I would say that it is in many ways much easier to use Unix land from Lisp land than the other way around.
<cranium_>
I mean awk still deals primarily with text and structures its data through text object (e.g. entries are separated by literal tabs). IIRC PowerShell of all things has brought some actually structured data into shell environments.
<Odin->
Why 'of all things'? :p
<cranium_>
Not sure. Or maybe because it's MS.
<Odin->
Microsoft probably has more people working on that kind of stuff that _aren't_ predisposed to think Unix had everything right than any other OS vendor.
thomasb06 has quit [Remote host closed the connection]
<Odin->
(Even the non-corporate ones.)
<MichaelRaskin>
As a huge shell lover, Powershell seems to lose enough ergonomics of shell that I can as well use a programming-first language with REPL. Be it Common Lisp, Julia, or even Python
<Odin->
The thing is, structured-data shells were one of the things Unix was built in rebellion against.
nicktick has quit [Ping timeout: 240 seconds]
<cranium_>
With what reasoning?
<mole1000>
I am a little upset about how much I have come to use powershell... I hate that I like it for some reason.
<nature>
All that is very interesting
<Odin->
cranium_: They were too complex, according to the Unix designers.
<contrapunctus>
beach: I see...my interest is piqued, but I'm embarrassed to say that I don't understand the idea completely. Could you give me an example of a situation where passing a pointer might be preferable?
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<beach>
contrapunctus: Performance is one aspect of it. But also preserving the identity. For example, if you have an information system with different modules presenting or processing (say) people or organizations, you don't want to end up with several copies of such an object. You would want a modification to an object by one module to be automatically reflected in other modules.
<cranium_>
I mean, I can't think of an example, but imagine you have programmatically generated some kind of tree structure (like a html tree). In a Unix world you would need to convert that to html (i.e. text), pass it to some other tool and that other tool has to parse it in again. But I'm not sure what is meant with the "identity" part.
<cranium_>
oh, so basically avoiding redundancy?
<beach>
Yes, copying loses identity, so how you must synchronize different copies.
<beach>
cranium_: It is also not semantically sane. What does it mean to have two copies of a person or an organization in one piece of software?
<Lycurgus>
unix is the default OS
<Lycurgus>
that battle is over
<Lycurgus>
as far as server is concerned
<beach>
Lycurgus: Not to a researcher, fortunately.
<Lycurgus>
oh?
xsperry has quit []
<Lycurgus>
it is sofar as I can tell for researchers a fortiorit
<cranium_>
I mean right now "the battle is over" but who knows what the world looks like in let's say.... 50 years.
<Lycurgus>
*fortiori
zefram22__ has quit [Ping timeout: 265 seconds]
<Lycurgus>
i remember a trade mag in the early 90s declaring unix dead
zefram22 has quit [Ping timeout: 260 seconds]
<beach>
Lycurgus: How would progress be possible if researchers accepted the mediocrity of the current situation?
<splittist>
There are many, many people who spend all day in Windows, of course.
<Lycurgus>
well you're taking about forward work
<beach>
Lycurgus: That's my job, yes.
<contrapunctus>
Lycurgus: UNIX was dead even in the eyes of its creators, it would seem, if you look at the Plan 9 papers.
<Lycurgus>
if they're working in research they most likely use that windows machine as a client to a network of unix servers
<cranium_>
You know that quote that goes "tomorrow's unix will be like today's Unix, only cruftier"? I think at some point there's gonna be so much cruft the whole thing won't be feasible anymore.
<Odin->
Lycurgus: C is the default programming language, too. You're here, so I don't expect you to think that using anything else is pointless.
<beach>
Odin-: Very good point.
<Lycurgus>
Odin - not following
<Lycurgus>
C is the machine lang of this time, if that's what you mean
<Lycurgus>
*c/c++
<Lycurgus>
oic
<cranium_>
Said differently: The unix model and its assumptions generated contradictions the instant it left the PDP-11 and at some point these are gonna be too much. See https://queue.acm.org/detail.cfm?id=3212479
<Lycurgus>
yes, lisp is one of my preferred langs with prolog and haskell
<Lycurgus>
but I will use java or js or whatever if there's a compelling reason
<Lycurgus>
btw, anybody used cl-react?
<cranium_>
That is to my understanding the canonical approach to choosing a tool.
<beach>
Lycurgus: I think Odin- (and me too) interpreted your Unix thing as meaning that we should all give up and just use it as it is and keep quiet.
<Odin->
Lycurgus: Unix is the default operating system, so everything has to accommodate its assumptions. That is true. But C is the default programming language, to the extent that ISAs are actually _specifically_ geared towards it, and everything also needs to accommodate its assumptions. Yet you're in an IRC channel geared towards Common Lisp, a language that very much does _not_ follow the same assumptions as C. So clea
<Odin->
rly you don't think that the fact that those assumptions need to be accommodated mean that they have to be taken as everything that's possible.
<Lycurgus>
that was a misread
<Lycurgus>
i was just reporting the current state of affairs
<beach>
Got it.
<Odin->
Well, it came into a discussion about alternative ways of operating, so I'll contend it was a reasonable read. :p
<Lycurgus>
like a lot of people I'm working on a lisp OS, an AI OS actually
<Lycurgus>
using the 3 langs mentioned
<MichaelRaskin>
Linux, is quite unassuming about what you do on top, os even if you run Linux for drivers, you can run a single Lisp image on top and do everything there
<Odin->
Linux is not Unix.
<Odin->
Like, at _all_.
<MichaelRaskin>
Maybe FFI a thing here and there when needed
<Lycurgus>
in my position of course I meant unix the concept which includes linux
<Odin->
Even the Linux distros are getting further and further away from anything you could sensibly call Unix-y.
<Lycurgus>
how is that?
<MichaelRaskin>
The part that goes away from Unix is pretty cheap to throw away
<Lycurgus>
at this point linux essentially defines unix
<Odin->
They're picking up huge pieces of what Unix was built as a contrast to.
<nature>
I would argue against that :)
<cranium_>
I mean you're gonna have to do things via Linux syscalls and conform to e.g. its filesystem semantics, so while it isn't "assuming", it definitely imposes certain ways of doing things.
<Lycurgus>
so that the latter only is relevant to the former, the thing that actually worked out
<beach>
Odin-: There is still a file system and the concept of a process.
<MichaelRaskin>
cranium_: you probably should have a partition with a filesystem it expects, but if you want to manage a raw block device directly, you are quite welcome
<cranium_>
Odin-, are you referring to systemd, wayland and such things?
<Odin->
beach: Sure. But file systems in particular are something that Unix decided didn't need to be rebelled against.
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
<beach>
Odin-: I don't understand. Unix was meant to be an "implementable subset of Multics" and Multics did not have a file system.
<beach>
Multics didn't distinguish between primary and secondary memory.
<Odin->
cranium_: They are part of it, but there's also a lot of stuff about how the kernel works. Mind you, they do keep the 'everything is a file, which is a sequence of bytes' nonsense...
daphnis has joined #lisp
<Odin->
beach: Uh, what? As I understood it, Multics was the first system to have a hierarchical file system.
<beach>
Odin-: Linux also still has the concept of a kernel, which Multics did not.
<cranium_>
beach, what did the memory thing mean in practice? That everything in RAM (which I assume _did_ still exist, von Neuman and so on) was persisted on the harddisk?
<beach>
Odin-: You are wrong. It was a hierarchy of "segments" which are like vectors rather than files.
<Odin->
beach: Considering that Unix considers files to be byte vectors, I don't see how you'd distinguish that from a Unix file system.
<beach>
Odin-: `read' as opposed to `a[i]'.
<cranium_>
I suppose it's about what's the interface semantics presented to the programmer.
<beach>
One is a sequence of bytes, the other one is a vector with random access.
<beach>
cranium_: Not quite, because of virtual memory. Primary memory was more like a cache for the system-wide hierarchy of segments.
<Odin->
beach: Where would `mmap` fall?
OlCe has quit [Ping timeout: 265 seconds]
<beach>
cranium_: Yes, exactly. Secondary memory did not have any different semantics.
<Odin->
... all you've done is convince me I need to go find a Multics emulator now. :p
<beach>
Odin-: mmap is a kludge to make something similar, and the Linux dynamic linker is a pale imitation of the Multics linker.
<aap>
there's a public multics you can get an account on
<MichaelRaskin>
Technically speaking, it is glibc dynamic linker
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<beach>
MichaelRaskin: Thanks!
<MichaelRaskin>
In the sense that one could have things linked with a different one side-by-side on the same Linux system
rumbler31 has joined #lisp
<Odin->
beach: So your argument is that Multics doesn't have the first hierarchical file system, because file systems are less featureful than what Multics had?
<beach>
Odin-: It had a hierarchical system, but not of files, because there was not the concept of a file. Just one type of memory. Someone implemented a "file system" on top of the Multics segment hierarchy, just to please people who wanted something worse.
<beach>
`vfile' I think it was called.
varjagg has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
<beach>
Furthermore, there was no kernel. Just a bunch of executable segments that could be replaced individually without taking the system down.
xsperry has joined #lisp
<beach>
Odin-: So there were no system calls OPEN/CLOSE/READ/WRITE.
<beach>
Odin-: You would just obtain a pointer to the beginning of a segment, and start using it as a vector of bytes.
<beach>
Pointers where in two parts, by the way segment-number,offset.
<beach>
Obtaining a pointer to a segment converted a path in the hierarchy to a segment number, but all that was transparent. The programmer and the user always dealt with segments by name.
<beach>
Now, Multics still had the concept of a process, because the address space was still too small. 18 bits for the segment number and 18 bits for the offset.
<beach>
And I don't think the Multics model would be a good one for a new operating system. Just better than Unix and Linux ever were.
vutral_ has joined #lisp
<aap>
hm, aren't full pointers 72 bits?
<beach>
Some things were 72 bits, but I forget the details.
OlCe has joined #lisp
<beach>
My (admittedly small) family just announced that dinner is served, so I am off for today. I'll be back tomorrow (UTC+2).
<jcowan>
I object to the claim that Unix pipes are "streams of bytes"; it is true only in the sense that a Lisp pair is a byte array.
Lycurgus has quit [Quit: Exeunt]
<nature>
Bye beach thanks for the very interesting insights!
<jcowan>
Also, the Multics supervisor was very much like the Linux kernel: it was mapped into the same virtual addresses in every process (its stack was mapped into different physical memory, of course), and it could not be replaced except by rebooting.
imode has joined #lisp
mister_m` has quit [Ping timeout: 245 seconds]
<jcowan>
(Indeed, you needed a special program to overwrite the boot media; the supervisor was not addressable as a file)
<semz>
"streams of bytes divided into often small but technically unbounded logical sections by 10s with an often implicit encoding"?
karlosz has joined #lisp
<semz>
I'm being snarky and think I understand what you're getting at, but the lack of explicit structure is one of the biggest problems imo
mindCrime has joined #lisp
nij is now known as Guest73981
nij has joined #lisp
hypercube has joined #lisp
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
srhm has quit [Quit: Konversation terminated!]
nij has quit [Quit: ERC (IRC client for Emacs 27.2)]
narimiran has quit [Ping timeout: 252 seconds]
vs^ has joined #lisp
narimiran has joined #lisp
zefram22 has joined #lisp
Guest73981 has quit [Read error: Connection reset by peer]
<jcowan>
One of the great breakthroughs in Multics was the provision of byte-stream files, which are closely related to Unix byte-stream pipes. All OSes before that, and many afterwards, had per-application formats, which made interoperability difficult or impossible.
Sauvin has quit [Remote host closed the connection]
sauvin_ has joined #lisp
<jcowan>
McIlroy's file structure test: write a program that copies itself to another file, run the program, and compile the copy. Most pre-UNIX OSes couldn't do that without introducing an expert who knew how to convert sequential output to whatever the compiler expects.
noobineer1 has quit [Read error: Connection reset by peer]
<flip214>
nature: slimv and vlime user, vlime in the past years. if you need help, just ask.
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
<Xach>
hmm, does anyone have any references to the serialize-to-fasl trick?
<Xach>
I seem to remember a technique like compiling a file consisting only of (defvar *var* #.*var*) or some such thing.
<Xach>
I'm having trouble finding it again.
karlosz has quit [Quit: karlosz]
<Bike>
i don't know what there is to explain beyond that? maybe that you have to have make-load-form defined
<Xach>
Hmm
gaqwas has joined #lisp
gaqwas has joined #lisp
nij has joined #lisp
luckless has joined #lisp
DHARMAKAYA has joined #lisp
klltkr has joined #lisp
sauvin_ has quit [Read error: Connection reset by peer]
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
<kevingal>
I've noticed a reference or two to "non-idiomatic" lisp code, what does that mean to y'all? Overuse of imperative / stateful programming style?
<kevingal>
I'm curious what Common Mistakes are made by new Common Lisp programmers.
yitzi has quit [Quit: yitzi]
mister_m` has joined #lisp
notzmv has quit [Ping timeout: 252 seconds]
<jasom>
kevingal: using assignment functions instead of their setf form (e.g. rplacd instead of (setf (cdr ...))); assigning to a special without first having a defvar/defparameter for it; having special variables without *earmuffs*; improper indentation of code; putting closing parentheses on their own line
<semz>
kevingal: I wouldn't say being imperative is unidiomatic for CL. For Scheme maybe. Typical unidiomatic code by beginners for me would be overuse of macros (especially for things that could easily be functions) and reimplementing some of the (admittedly extensive) standard facilities.
ebrasca has quit [Read error: Connection reset by peer]
<jasom>
kevingal: Then there's the "learned lisp in Uni" errors: using symbol plists instead of hash-tables; using tail-recursion instead of looping constructs; putting everything in cl-user.
<nij>
Oooh! I'm making many newbs mistakes.
<kevingal>
Interesting, thanks. Why is the setf form preferred to the likes of rplacd?
<nij>
jasom: do you mean I should use looping constructs but not tail-recursion?
<nij>
Also.. why do we need to defvar/defparameter in the first place?
<jasom>
kevingal: mainly because it's more obvious that (setf (cdr x)) is the mutator for (cdr x); rplacd predates generalized references
<jasom>
kevingal: you'll notice there isn't a "sethash" just (setf (gethash...))
zefram22 has quit [Quit: zefram22]
<jasom>
nij: you should use what is most clear to represent the problem. Going through contortions to turn iterative code into tail-recursion is not idiomatic. Plus CL makes no guarantees about elminating tail-calls (and dynamic binding can make it harder to visually identify what is and isn't a tail-call)
zefram22 has joined #lisp
<jasom>
nij: you need defvar/defparameter because (setf *foo* 3) is ill-defined code; most implementations will just assume that *foo* is supposed to be special, but it's not guaranteed. Plus the declaration allows for dynamic-binding in a LET form which can be very handy
ebrasca has joined #lisp
<jasom>
speaking of dynamic bindings another non-idiomatic form is: (let ((old-foo *foo*)) (setf *foo* 3) (unwind-protect (...) (setf *foo* old-foo)) instead of (let ((*foo* 3)) ...)
<nij>
jasom: yeah.. lisp does warn me when I setf right away. But it always worked for me.. when will it crash and why is it bad?
<nij>
(setf a 1) => 1
<Bike>
implementations don't have to support that
<nij>
(let ((b 3)) (+ a b)) => 4
<Bike>
most of them do, but relying on that makes your code nonconforming
<nij>
Oh, I see. It is not the standard.
<Bike>
also, stylistically, declaiming a variable special is much better than just using it immediately
<jasom>
nij: that has 2 non-idiomatics for the price of 1; special variables should have *earmuffs* on their names
<Bike>
variables showing up with no definition is confusing to the reader
<nij>
I see.
<jasom>
nij: (defvar x) (let ((x 1) (y 2)) ...) ;; the bindings for x and y are very different due to x being declared special
<kevingal>
jasom: makes sense, rplacd has always seemed like a horrendous name to me. Not sure if 'car' and 'cdr' seem less bad only because I've gotten used to them.
<nature>
flip214: Thanks! My initial question was if I am going to lose much by straying away from the standard emacs+SLIME setup, since I am really confortable with vi-like bindings?
<jasom>
kevingal: If I had to guess, the name is because there was some machine with 6-bit characters and 36-bit words so 6 letters would fit in a single machine word
<kevingal>
I wasn't aware that CL didn't guarantee tail-call optimisation!
<nij>
If not emacs+SLIME, I'm not sure if there's any good IDE for common-lisp.
<jasom>
kevingal: most implementations do it most of the time. gnu clisp won't do it when interpreting code, only with compiled code.
<kevingal>
Ya, I no longer question historical design decisions, I just accept them, ha.
<jasom>
nature: I'm a lifelong vim user; I recommend evil-mode on emacs
slyrus has joined #lisp
<jasom>
nature: I hear slimv (a slime-like vim plugin) is pretty good these days; it was completely unusable when I first used it so I just got emacs setup the way I wanted it.
<nij>
I started with vim and ended up with evil-mode. It will take you some time to get used to emacs.. but it'd worth it (cuz it's lisp :D)!
<jasom>
nature: literally the only thing you need to know that's emacs specific once you get setup with evil-mode is "control-g instead of escape"
<jasom>
nature: (that's for getting out of weird dialogs; escape still exits insert mode like normal)
<nij>
jasom: it'd be a little bit intimidating if nature just wants to play with lisp.
<nij>
entering emacs is somehow hard in that it takes time to get used to it
<jasom>
for just playing with lisp, edit in vim, use emacs/slime as your repl and just mouse around
<jasom>
I did that for 5 years
<nij>
I was a bit unhappy that slime/sly is almost exclusive for emacs user..
<nij>
Btw, I'm amazed after I macroexpand-1 some setf form..
<nature>
It felt a bit "overkill" to use emacs just for lisp, thanks for the recom tho, I might give a shot to evil mode then
<nij>
But I cannot find its source. Not even with `M-x sly-edit-definition`.
<Bike>
the source of macroexpand-1?
<jasom>
nature: it felt that way for me too for a bit; I was using rlwrap on sbcl. It was a *huge* improvement to just use the SLIME repl and nothing else from emacs
<Xach>
that is why many people use emacs for filesystem management, reading mail, reading usenet, taking notes, managing their calendar, chatting on irc...it's a little bit wasteful to use it just for lisp hacking.
orivej has joined #lisp
<nij>
I'd say vimmer mindset and emacser mindset are quite different.
<nij>
Dunno if I can persuade the my past self if not deceiving him!
<Bike>
can you get the source of other standard functions?
<nij>
But really, I think what truly makes emacs stands out is and only is (its great community + LISP).
<nij>
Bike: Can't we :O?!?!
<nature>
Okay thanks :)
<Bike>
i'm just wondering if your implemenation's source isn't hooked in properly
<jasom>
Well operating systems are only as good as their applications and the emacs community is what writes the applications for the emacs OS. Now with evil-mode it has a good editor too :)
<nij>
Oh I see Bike.. hmm lemme the message again.
<kagevf>
I've been using vim since 2011, love it, use its emulation plugins in other editors, but I use emacs for the last 18 months to take notes and code Lisp ... I just use vanilla emacs .... your muscle memory eventually catches up
<nij>
Oh no apparently not.. it says "/home/christophe/..." doesn't exist.
<nij>
I'm not christophe by the way.
<Bike>
that's pretty weird.
<nij>
I'm on doomemacs.. this is the price to pay for my laziness!
<Xach>
nij: (sb-ext:set-sbcl-source-location "/path/to/sbcl/sources") might help
<nij>
kagevf: yeah! me too! org-mode hooked me in the first place
<kagevf>
also, I like the fact that emacs keybindings work in any context - minibuffer, dired, slime repl ... the only caveat being that a mode can over-write it, but in general the keybindings are very consistent, even compared to vim
grnman_ has joined #lisp
zefram22 has quit [Ping timeout: 240 seconds]
<nij>
Vim is great cuz it's minimal~
<kagevf>
nij: I started with org mode first, and that was great for getting used to emacs, so a few months later when I started learning Lisp I was already comfortable with emacs ... worked out well, I think :)
<nij>
I got hooked to vim because of that. And then I discovered even more minimal editor, like vi.
<nij>
And that's the point I discard minimalism and embraced emacs.
<nij>
kagevf: pretty similar here ! And then I discovered lisp is the most elegant lang. Doomed, fell in love!
<nature>
I mostly use vi tho ^^' But I suppose I'll have to give in to emacs in order to get some "serious" coding
<nij>
Vi/Vim/Nvim are nice, and with enough skills you can do a lot. But... but .. it's not lisp.
<Josh_2>
TIL that special variables should be earmuffed
<nij>
Xach: Ah, that might be the reason. I didn't compile sbcl myself. So no source code.. Maybe I should do that.
<nij>
But it seems that you're indicating I should look for the source for setf in sbcl. I will do that.
daphnis has quit [Ping timeout: 245 seconds]
<nij>
Is it the case that every cl implementation has different definition of setf?
boogsbunny has quit [Ping timeout: 240 seconds]
<MichaelRaskin>
I would believe so
walex has quit [Ping timeout: 260 seconds]
<Krystof>
nij: I am christophe, although if you are using Debian I am not christophe any more
<nij>
Lol you serious?
<nij>
I'm using arch. You are that christophe?
<Krystof>
I don't know! Possibly not :)
<Krystof>
If you're using an x86-64 binary downloaded from SourceForge, then yes. Otherwise no.
<Krystof>
And this doesn't particularly help your actual problem, but "hi" anyway
<nij>
"hi"! I was about to yell "What a small world!"
<nij>
and I realize.. yeah of course, this is the world about lisp.
<Bike>
if you installed sbcl from pacman it should have sources in in /usr/share/sbcl-source
<mole1000>
Yeah you are figuratively in a small world right now
<nij>
mole1000: that's great. I always like smaller world.
<nij>
The actual size of the real world has been more and more scary for me.
shka_ has quit [Ping timeout: 240 seconds]
vs^ has quit []
notzmv has joined #lisp
daphnis has joined #lisp
CrashTestDummy3 has joined #lisp
curtosis has joined #lisp
CrashTestDummy2 has quit [Ping timeout: 246 seconds]
mole1000_ has joined #lisp
mole1000 has quit [Ping timeout: 245 seconds]
<p_l>
anyone knows if weblocks is still in working shape?
<Shinmera>
I know someone revived it
<sveit>
hi. in Haskell (and C++) there is support for so-called "constructor elision". This means that if one function allocations a structure, and the values from that structure are immediately extracted, the structure is never allocated. Will any of the compilers do this (or can they be coaxed to)?
<Shinmera>
But don't know what the canonical url for that is
<Josh_2>
the -p naming convention is for functions that return either t or nil right? I shouldn't use if I return t or signal a condition?
<Shinmera>
sveit: if you inline the constructor for a structure you can declare it dynamic extent in SBCL at least.
<Shinmera>
Josh_2: -p is for predicates. They may also return a generalised boolean.
<p_l>
Generally considering using it because I need to build a few apps that could be web based and I need something quick and dirty to get UI working... and I'm not great at web uis
<Shinmera>
Josh_2: What you're thinking of is usually a check-* function.
<Josh_2>
okay coolio
<Josh_2>
What do you mean by a 'generalized boolean' ?
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<sveit>
thanks. this is very cool, SBCL is incredible.
nij has left #lisp ["ERC (IRC client for Emacs 27.2)"]
wsinatra has quit [Quit: WeeChat 3.1]
<sveit>
so what remains unclear is if I have a function returning a struct, and I declare a variable it is bound to dynamic-extent, will its result get stack allocated?
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
<sveit>
that seems almost impossible in a dynamic language...
<sveit>
assuming the struct has an inlinable constructor of course
<Bike>
i don't think it will
mole1000_ has quit [Quit: Leaving]
<Bike>
maybe if it's inlined?
<Bike>
the function returning a struct, i mean
<jasom>
be aware that dynamic-extent allocation has a fairly small effect on runtime thanks to the efficiency of SBCL's nursery collector
<Shinmera>
Depends. It can be well worth it to avoid triggering gcs.
bitmapper has quit [Quit: Connection closed for inactivity]
gumman has quit [Read error: Connection reset by peer]
gumman has joined #lisp
<Josh_2>
can't use methods on conditions :(
<Josh_2>
well thats vague, I mean can't dispatch on conditions
Oddity- has joined #lisp
<p_l>
nature: thanks :)
<Bike>
you should be able to specialize on condition classes, Josh_2
ikrabbe|2 has quit [Ping timeout: 245 seconds]
narimiran has quit [Ping timeout: 245 seconds]
<Mandus>
nature: here's another vim/slimv-person lurking around. I do a fair bit of hobby-programming in that envir and i suits me well (and I do all my paid work in vim too, but that's in other languages).
Oddity has quit [Ping timeout: 258 seconds]
<Josh_2>
Bike: if I use something like find-class?
<Bike>
that doesn't seem directly related, but yeah, you can probably use find-class on condition types
<Bike>
the standard is a little vague on this point, but i don't think any actual implementation makes condition types not be classes
<Shinmera>
What you can't specialise conditions on is initialize-instance.
<Shinmera>
well, you can, but it won't do anything.
<Shinmera>
at least not on sbcl
DHARMAKAYA has joined #lisp
<Josh_2>
Yep seems I'm just rarted
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<phoe>
all implementations implement conditions as classes
ikrabbe|2 has joined #lisp
<phoe>
and all except SBCL use standard-objects
akoana has joined #lisp
<phoe>
(where "all except SBCL" means CCL, ECL, Clasp, ABCL, CLISP, LispWorks, and ACL)
<phoe>
(and "all" means the above plus SBCL)
<phoe>
there's my ticket on SBCL that proposes adding initialize-instance support to condition classes, but it's not solved
threenuc has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Josh_2>
I had a smooth brain moment when and made a mistake naming the class in my defmethod
<phoe>
actually (defmethod foo ((thing condition) ...) ...) should work just fine
<phoe>
same with condition subclasses
vutral_ has quit [Quit: Connection closed for inactivity]
rodriga has quit [Ping timeout: 252 seconds]
amb007 has quit [Read error: Connection reset by peer]
bitmapper has joined #lisp
amb007 has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
pve has quit [Quit: leaving]
daphnis has quit [Ping timeout: 265 seconds]
cage_ has quit [Quit: Leaving]
zzappie has joined #lisp
karlosz has quit [Quit: karlosz]
gaqwas has quit [Ping timeout: 252 seconds]
Gromboli8 has joined #lisp
zefram22 has joined #lisp
DHARMAKAYA has quit [Ping timeout: 250 seconds]
Gromboli has quit [Ping timeout: 240 seconds]
Gromboli8 is now known as Gromboli
amb007 has quit [Read error: Connection reset by peer]
anticrisis has joined #lisp
amb007 has joined #lisp
theothornhill has joined #lisp
karlosz has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
karlosz_ has joined #lisp
amb007 has joined #lisp
karlosz has quit [Ping timeout: 252 seconds]
karlosz_ is now known as karlosz
dsrt^ has joined #lisp
andrei-n has quit [Quit: Leaving]
<nick3000>
/?
heisig has quit [Quit: Leaving]
nature has quit [Ping timeout: 260 seconds]
boogsbunny has joined #lisp
rumbler31 has joined #lisp
scymtym has joined #lisp
theothornhill has quit [Remote host closed the connection]
hypercube has joined #lisp
zzappie has quit [Ping timeout: 240 seconds]
varjagg has quit [Ping timeout: 252 seconds]
luckless has quit [Ping timeout: 240 seconds]
hypercube has quit [Quit: WeeChat 3.1]
luckless has joined #lisp
OlCe has quit [Ping timeout: 252 seconds]
rumbler31 has quit [Remote host closed the connection]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
hiroaki_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
boogsbunny has quit [Ping timeout: 240 seconds]
tempest_nox has joined #lisp
surabax has quit [Quit: Leaving]
phantomics_ has quit [Quit: Ex-Chat]
phantomics has joined #lisp
dyelar has quit [Quit: Leaving.]
Nilby has joined #lisp
<threenuc>
Hi. How do I write an S-expr for "tag which does not have the attribute 'lang'"? (tag (attribute_name @_attr) (#not-eq @attr "lang")) matches when it finds any attribute that is not "lang", eg <div hello lang>
random-nick has quit [Ping timeout: 260 seconds]
attila_lendvai has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
I dunno, how did you come up with the rest of that expression?