akhetopnu has quit [Quit: Konversation terminated!]
orivej has joined #lisp
dale has joined #lisp
Khisanth has joined #lisp
bitmapper has quit [Read error: Connection reset by peer]
rwcom has quit [Ping timeout: 272 seconds]
bitmapper has joined #lisp
rwcom has joined #lisp
mathrick_ has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
z147 has quit [Quit: z147]
gko_ has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
prince1 has joined #lisp
onceagain has joined #lisp
ak5 has joined #lisp
prince1 has quit [Ping timeout: 265 seconds]
<onceagain>
Just wanted to see if anyone's dealt with this, when I compile my file on vlime I get a package not found error even the package is recognized when I run the program line by line from the SBCL repl. I'm thinking it has something to do with my swank setup, any ideas what might be going on?
<onceagain>
I'm pretty sure it's on the first line (ql:quickload :croatoan)
karlosz has joined #lisp
ebrasca has joined #lisp
<didi>
So I finally used `macrolet' for the first time. This must be a milestone of some sort.
ebrasca has quit [Remote host closed the connection]
ebrasca has joined #lisp
Inline has quit [Ping timeout: 272 seconds]
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
wxie has quit [Quit: wxie]
akoana has joined #lisp
didi has quit [Ping timeout: 260 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
<Bike>
onceagain: compile-file doesn't execute as it goes, so e.g. the quickload is only compiled, not executed, when the later forms using :croatoan packages are compiled
<Xach>
how can i be 37 minutes and 5 seconds late?
<Xach>
I was just going to type that.
bitmapper has quit [Ping timeout: 240 seconds]
<onceagain>
@Bike Interesting, I guess I don't really understand why it would throw an error though if that's the case?
<Bike>
onceagain: the package hasn't been defined, so it doesn't exist, so the reader can't read your code
<onceagain>
Hmm well the next line after the quickload is (in-package :croatoan), does that not define the package?
<Bike>
no it does not
<Bike>
it just tells the compiler and reader and stuff to use that package
<onceagain>
Would you happen to have a good linke or reference to start reading about this kind of thing? I don't think I have enough understanding of compile-file to get this working yet
<onceagain>
I guess I could start with the documentation on compile-file, it helps to know that this isn't some kind of swank issue
<White_Flame>
the proper fix is not to have quickloads inline in your source code, or really anything that defines packages in the same source that uses them syntactically
<White_Flame>
put them in a separate file that's loaded beforehand, or preferably set up an .asd file for your project which can declare its dependencies
<White_Flame>
either that, or when you're working interactively just ensure you bring up your dependencies manually before using the file
<White_Flame>
as far as learning, the biggest issue is knowing what the reader does
<White_Flame>
and that a package must exist before a form using its symbols is even read
<White_Flame>
If you haven't read PCL, it's a good programmer's interoduction to lisp which also covers packages & symbols: http://www.gigamonkeys.com/book/
<White_Flame>
(chapter 21)
karlosz has quit [Quit: karlosz]
<onceagain>
White_Flame it looks like I have a lot to learn! Thanks for the advice, I'm pretty new to all this. I've been reading through CL: a gentle introduction, but sometimes I get antsy and want to figure out my workflow more quickly. I was originally sending things line by line through Tslime to a tmux pane running SBCL, but the output there is kinda
<onceagain>
hard on the eyes compared to vlime
<onceagain>
I'll make sure to check out that chapter and some more resources on the full setup needed for compiling files
<White_Flame>
yeah, symbols & packages are definitely something that isn't obvious at first glance, but are actually pretty simple
<White_Flame>
just remember that compiling (ql:quickload "something") doesn't execute it
<White_Flame>
and thus doesn't actually have the dependency loaded when your next lines are read for compilation
<onceagain>
I remember reading that SBCL can be run either as a compiled language or a scripting language, but does this all mean you can't really run an uncompiled script that uses an outside package? Or is scripting in lisp just not the way to go in general
<Xach>
onceagain: you can indicate that certain forms should have an action at compile-time
<White_Flame>
Lisp's history involved a lot of Lisp OSes, so it tends to own its own environment moreso than being involved in scripts. But scripts are doable
<Bike>
well, if you want it to run like a script, run it like a script. compile-file doesn't
<Xach>
eval-when is the tool
<onceagain>
Good to know! Thanks again, I'm gonna do some reading to sort myself out a bit
ebzzry has joined #lisp
madrik has quit [Quit: Busy]
rwcom1 has joined #lisp
rwcom has quit [Ping timeout: 240 seconds]
rwcom1 is now known as rwcom
ebzzry has quit [Ping timeout: 272 seconds]
ebzzry has joined #lisp
Tolstoy- has joined #lisp
Tolstoy- has quit [Remote host closed the connection]
notzmv has joined #lisp
prince1 has joined #lisp
prince1 has quit [Ping timeout: 260 seconds]
xkapastel has joined #lisp
prince1 has joined #lisp
prince1 has quit [Ping timeout: 260 seconds]
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
orivej has joined #lisp
mathrick_ has joined #lisp
orivej has quit [Ping timeout: 255 seconds]
orivej has joined #lisp
wxie1 has joined #lisp
<beach>
Good morning everyone!
wxie1 is now known as wxie
ebzzry has quit [Read error: Connection reset by peer]
<ebrasca>
Morning!
<no-defun-allowed>
Good morning ebrasca.
madrik has joined #lisp
_whitelogger has joined #lisp
Tolstoy- has joined #lisp
ebrasca has quit [Remote host closed the connection]
asarch has joined #lisp
<madrik>
Before Common Lisp's condition system, how did earlier Lisp such as Maclisp and Interlisp handle errors and exceptions? Was it something like CATCH and THROW only?
<beach>
Yes, I think that's true.
ealfonso has quit [Ping timeout: 240 seconds]
<beach>
... at least for Maclisp. I don't know about Interlisp.
shangul has joined #lisp
<beach>
Interesting relate fact: The condition system was inspired by that of Multics PL/I, and PL/I on Multics was an excellent development environment, especially considering when it existed.
vaporatorius has quit [Read error: Connection reset by peer]
wxie has joined #lisp
torbo has joined #lisp
wxie has quit [Remote host closed the connection]
Josh_2 has quit [Ping timeout: 258 seconds]
wxie1 has joined #lisp
ak5 has quit [Ping timeout: 265 seconds]
ak5 has joined #lisp
shangul has quit [Remote host closed the connection]
shangul has joined #lisp
vaporatorius has joined #lisp
wxie1 has quit [Ping timeout: 240 seconds]
ebzzry has joined #lisp
vaporatorius has quit [Ping timeout: 260 seconds]
ak5 has quit [Quit: WeeChat 2.7]
<madrik>
beach: So, might we say that Emacs Lisp is somewhat a Maclisp of today?
<madrik>
edgar-rft: Thanks for the link.
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
<madrik>
What were FEXPRS?
<beach>
madrik: In a way, yes. But Emacs Lisp has evolved.
<beach>
madrik: Functions that did not evaluate their arguments.
<beach>
They were replaced by macros for reasons of performance. Macros are handled at compile time.
prince1 has joined #lisp
prince1 has quit [Ping timeout: 255 seconds]
<madrik>
beach: When were macros invented?
<beach>
madrik: Initially, Emacs Lisp had only dynamic bindings, whereas Maclisp had dynamic bindings in the interpreter and lexical bindings in the compiler.
<beach>
I don't remember when macros were invented. Sorry.
<madrik>
beach: Wow. Different bindings in different environments? Wasn't that a pain?
<beach>
It was less of a problem than you might think. Most people wrote programs that were intended to behave as if bindings were lexical anyway. Taking advantage of dynamic bindings was exceptional.
<beach>
So whether such a program ran in the interpreter or in the compiler did not make a difference.
<beach>
Interestingly, Franz Lisp (a predecessor of Allegro Common Lisp in a way) went to a lot of trouble to make compiled code use dynamic bindings. At the time, dynamic bindings were thought to be the norm. I think this is where Scheme showed the way, and inspired Common Lisp to use lexical bindings everywhere.
slyrus__ has joined #lisp
<edgar-rft>
madrik: https://en.wikipedia.org/wiki/Macro_(computer_science)#Early_Lisp_macros says "In 1963, Timothy Hart proposed adding macros to Lisp 1.5 in AI Memo 57: MACRO Definitions for LISP." with link to the original document. I have no idea if that is true bcause I wasn't even born at that time :-)
slyrus_ has quit [Ping timeout: 260 seconds]
<madrik>
edgar-rft: Hmm. That was about 30 BM (Before Me :)
space_otter has joined #lisp
<madrik>
Out of curiosity, I know that popular Lisp systems currently feature a compiler as given, with an optional interpreter. Are there any systems with _only_ a Common Lisp interpreter?
shangul has quit [Ping timeout: 258 seconds]
<edgar-rft>
madrik: https://almy.us/xlisp.html is the only one I know, but it's not a full implementation of Common Lisp
<madrik>
edgar-rft: Thanks.
vlatkoB has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
ebzzry has joined #lisp
prince1 has joined #lisp
Khisanth has quit [Ping timeout: 258 seconds]
gravicappa has joined #lisp
sz0 has joined #lisp
froggey has quit [Ping timeout: 260 seconds]
verisimilitude has left #lisp ["ERC (IRC client for Emacs 24.5.1)"]
froggey has joined #lisp
Khisanth has joined #lisp
_whitelogger has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
EvW has quit [Ping timeout: 248 seconds]
Nikotiini has quit [Ping timeout: 268 seconds]
gabiruh has quit [Ping timeout: 260 seconds]
Nikotiini has joined #lisp
asarch has quit [Quit: Leaving]
shangul has joined #lisp
prince1 has quit [Ping timeout: 272 seconds]
dddddd has quit [Remote host closed the connection]
Bourne has joined #lisp
shangul has quit [Ping timeout: 260 seconds]
Bike has quit [Quit: leaving]
narimiran has joined #lisp
Bourne has quit [Ping timeout: 272 seconds]
hiroaki has joined #lisp
onceagain has quit [Ping timeout: 260 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ is now known as Lord_of_Life
gravicappa has quit [Ping timeout: 260 seconds]
fanta1 has joined #lisp
shka_ has joined #lisp
Jeanne-Kamikaze has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 240 seconds]
gko_ has quit [Ping timeout: 255 seconds]
ebzzry has quit [Ping timeout: 272 seconds]
heisig has joined #lisp
sauvin has quit [K-Lined]
sauvin has joined #lisp
akoana has quit [Quit: leaving]
sauvin has quit [Ping timeout: 255 seconds]
sauvin has joined #lisp
hiroaki_ has joined #lisp
karlosz has joined #lisp
hiroaki has quit [Ping timeout: 260 seconds]
torbo has quit [Remote host closed the connection]
jeosol has quit [Ping timeout: 260 seconds]
madrik has quit [Ping timeout: 265 seconds]
rwcom8 has joined #lisp
rwcom has quit [Ping timeout: 265 seconds]
rwcom8 is now known as rwcom
prince1 has joined #lisp
prince1 has quit [Ping timeout: 268 seconds]
Bourne has joined #lisp
nowhereman has joined #lisp
Bourne has quit [Ping timeout: 258 seconds]
shka_ has joined #lisp
heisig has quit [Remote host closed the connection]
heisig has joined #lisp
Bourne has joined #lisp
random-nick has joined #lisp
karlosz has quit [Quit: karlosz]
nirved has quit [Ping timeout: 272 seconds]
dale has quit [Quit: My computer has gone to sleep]
nirved has joined #lisp
orivej has joined #lisp
cosimone has joined #lisp
Inline has joined #lisp
ebzzry has joined #lisp
<no-defun-allowed>
How are accessors generated in the MOP?
nowhereman has quit [Ping timeout: 268 seconds]
zzzzaike has joined #lisp
zzzzaike has quit [Remote host closed the connection]
kslt1 has joined #lisp
varjag has joined #lisp
heisig has quit [Ping timeout: 260 seconds]
madrik has joined #lisp
jonatack has quit [Quit: jonatack]
prince1 has joined #lisp
Ven`` has joined #lisp
Bourne has quit [Ping timeout: 272 seconds]
cosimone has quit [Quit: Quit.]
prince1 has quit [Ping timeout: 268 seconds]
ebzzry has quit [Read error: Connection reset by peer]
Bourne has joined #lisp
ebzzry has joined #lisp
rippa has joined #lisp
jonatack has joined #lisp
Tordek has quit [Ping timeout: 240 seconds]
scymtym has quit [Remote host closed the connection]
vert2 has quit [Ping timeout: 240 seconds]
vert2 has joined #lisp
Tordek has joined #lisp
Bourne has quit [Ping timeout: 258 seconds]
amnesia_ has joined #lisp
<amnesia_>
hello people
Bourne has joined #lisp
<p_l>
madrik: some systems can be run with just evaluator, but Common Lisp requires "minimal compilation" (expansion of macros etc.)
<p_l>
technically some implementations skirt this literally but preserve the required semantics, like LW which uses evaluator when tracing macros
<p_l>
(it puts macros in uncompiled state for the tracing)
shifty has joined #lisp
space_otter has quit [Remote host closed the connection]
nullman has quit [Ping timeout: 258 seconds]
nullman has joined #lisp
gko_ has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
scymtym has joined #lisp
v0|d has quit [Remote host closed the connection]
<Posterdati>
amnesia_: hello single people
rozenglass has joined #lisp
FreeBirdLjj has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
scymtym has quit [Remote host closed the connection]
scymtym_ has joined #lisp
prince1 has joined #lisp
nowhere_man has joined #lisp
X-Scale has quit [Ping timeout: 260 seconds]
prince1 has quit [Ping timeout: 260 seconds]
scymtym_ has quit [Remote host closed the connection]
ljavorsk has joined #lisp
scymtym has joined #lisp
kslt1 has quit [Remote host closed the connection]
metabyt[m] has joined #lisp
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
dddddd has joined #lisp
froggey has quit [Ping timeout: 255 seconds]
varjag has quit [Ping timeout: 258 seconds]
varjag has joined #lisp
froggey has joined #lisp
<vegai>
I suppose there's nothing comparable to SLIME for Visual Studio Code?
<Shinmera>
No
<Shinmera>
There's nothing comparable to Slime anywhere except in Emacs, unfortunately.
ebrasca has joined #lisp
<beach>
no-defun-allowed: I am not sure what your question means.
<nirved>
Genera is kinda comparable to Slime
<beach>
no-defun-allowed: The default would be to create a method like (defmethod some-reader ((x some-class)) (slot-value x 'the-slot-name)), but there are ways of making it faster. When the effective method is created, it is often possible to use standard-instance-access instead, which is much faster.
Bike has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
_paul0 has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
<madrik>
p_l: Thanks.
_paul0 has joined #lisp
FreeBirdLjj has joined #lisp
gravicappa has joined #lisp
<Posterdati>
cffi, antik and gsll are broken again in openbsd
FreeBirdLjj has quit [Ping timeout: 240 seconds]
lucasb has joined #lisp
fivo has joined #lisp
Ven`` has joined #lisp
shangul has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
rozenglass has quit [Ping timeout: 268 seconds]
shangul has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 272 seconds]
X-Scale has quit [Ping timeout: 258 seconds]
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
madage has quit [Remote host closed the connection]
slyrus__ has quit [Ping timeout: 272 seconds]
madage has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
bitmapper has joined #lisp
rwcom6 has joined #lisp
nowhere_man has quit [Ping timeout: 255 seconds]
rwcom has quit [Ping timeout: 258 seconds]
rwcom6 is now known as rwcom
amerlyq has joined #lisp
EvW has joined #lisp
prince1 has joined #lisp
FreeBirdLjj has joined #lisp
prince1 has quit [Ping timeout: 265 seconds]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
terpri has quit [Remote host closed the connection]
efm has quit [Remote host closed the connection]
efm has joined #lisp
ArthurStrong has joined #lisp
rixard_ has joined #lisp
rixard has quit [Ping timeout: 268 seconds]
shifty has quit [Ping timeout: 272 seconds]
EvW has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 272 seconds]
v0|d has joined #lisp
heisig has joined #lisp
EvW has joined #lisp
rixard has joined #lisp
tbs has joined #lisp
rixard_ has quit [Ping timeout: 255 seconds]
ljavorsk has quit [Ping timeout: 255 seconds]
bitmapper has quit [Ping timeout: 258 seconds]
cosimone has joined #lisp
shangul has joined #lisp
bitmapper has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
shangul has quit [Ping timeout: 260 seconds]
<pjb>
madrik: macros were invented in 1964 (same year I was born!)
hsaziz has joined #lisp
<pjb>
well, s/invented/implemented/
<hsaziz>
After removing a distro installed version of SLIME, my MELPA (stable) installed SLIME version still insists on accessing the old system wide swank-loader.lisp.
<hsaziz>
How do I purge the system and reset the path to swank-loader.lisp?
slyrus has joined #lisp
prince1 has joined #lisp
Bourne has quit [Ping timeout: 240 seconds]
prince1 has quit [Ping timeout: 268 seconds]
hsaziz1 has joined #lisp
<madrik>
pjb: Was this in Maclisp or Interlisp or some other Lisp?
<madrik>
hsaziz: Did you restart Emacs?
<pjb>
madrik: I thought it was in MacLisp, but this AIM talks about LISP 1.5…
<hsaziz>
madrik: Several times, including reboots.
<pjb>
MacLISP forked in 1966 from LISP 1.5. So it probably included macro from the start. Perhaps it was the first one to have macros exactly like our defmacro. I've not read the AIM 57 yet, but it looks like they hacked macros over FEXPRs…
gravicappa has quit [Read error: Connection reset by peer]
<madrik>
hsaziz: What Linux is this?
Jeanne-Kamikaze has joined #lisp
<hsaziz>
Ubuntu
<hsaziz>
Also had the same problem many years ago on Debian on a MIPS based SOC board.
rwcom9 has joined #lisp
<hsaziz>
Ubuntu 1910 if it matters
<_death>
don't use melpa for slime.. quicklisp-slime-helper is acceptable, or clone the repo and config yourself
rwcom has quit [Ping timeout: 268 seconds]
rwcom9 is now known as rwcom
<madrik>
hsaziz: I've faced this too. I can't remember how I solved it.
<hsaziz>
I am not, yet, comfortable enough with LISP, to do a lot of my own configuring!
<madrik>
_death: Should we not use either MELPA or the distribution's repositories in any circumstance?
gravicappa has joined #lisp
<phoe>
madrik: never use distribution's repositories
<madrik>
pjb: Which reminds me, how is ISLISP nowadays?
<pjb>
Niche.
Bourne has joined #lisp
<pjb>
There are a couple of implementations.
<phoe>
for slime use either (ql:quickload :quicklisp-slime-helper) or the one from melpa (e.g. bundled in spacemacs), and don't mix the two
gko_ has quit [Ping timeout: 260 seconds]
<madrik>
hsaziz: Did you 'apt-get remove slime' or 'apt-get purge slime'?
<_death>
madrik: melpa is ok for emacs packages (although personally I hacked things so that I can easily diff changes and roll back if needed) but when it comes to CL, quicklisp or DIY package management is the way
<hsaziz>
I am being daft! I am typing this on Ubuntu 1910 and therefore had this in mind. I am actually having this issue on an ancient machine running Trisquel 8, which is also Ubuntu based. I think 16.04.
<hsaziz>
madrik: apt remove slime
Bourne has quit [Ping timeout: 258 seconds]
<madrik>
_death: I am aware that most languages today opt for and encourage the use of their own package management systems. But then, why do the maintainers of distributions spend so much time and effort integrating things?
FreeBirdLjj has joined #lisp
<madrik>
hsaziz: Try to purge it. That should get rid of lingering configuration files.
<_death>
madrik: you'll have to ask them why.. maybe they just think "I'm a dist maintainer, I need to do my job"
<_death>
madrik: whereas a language user cares more about his particular niche working without pain
<madrik>
_death: Hmm. I can see either side.
FreeBirdLjj has quit [Ping timeout: 246 seconds]
ljavorsk has joined #lisp
Bourne has joined #lisp
<_death>
madrik: maybe the difference is between "users" and "developers".. a dist maintainer sees "users" and tune to their perceived interests, while a "developers" are a fickle bunch that don't really form a homogeneous group of users, each subgroup can have different forces shaping its interests and values
<madrik>
_death: Indeed.
<madrik>
I tend toward the distribution's view because when I obtain my software from my (distribution) vendor, I almost always get a managed, stress-free, well-put-together environment. The upgrades and security updates are taken care of, and the different components are made to work with each other.
<_death>
this also happens with quicklisp, but to a lesser degree
gareppa has joined #lisp
<amerlyq>
madrik: maintainer thing is all about "fit all things together in global namespace" -- to actually reduce complexity and unavoidable context fragmentation
<madrik>
The objection to the distribution's view is that old software may have unfixed bugs dealt with in the newer versions.
efm has quit [Read error: Connection reset by peer]
<_death>
madrik: sure, I update some software via distribution, but when it comes to CL my method of "updating" is a git-fetch-all script and skimming new commits, putting more scrutiny into libraries I actually care about
<madrik>
To which the reply is that newer software may have unseen bugs or feature changes.
<madrik>
_death: Yes. I understand it is a trade-off.
<madrik>
In managing things yourself, you get control, but you also must exercise more responsibility. Whereas you can delegate a sizeable chunk of administration to the distribution on the other view.
<amerlyq>
I think the main point is splitting steps of "I'm ready to update all my software and deps" .vs. "I'm ready to do dev work". It's easy with distributors soft, but somewhat tiresome and opaque with quicklisp
<madrik>
amerlyq: Just to tee off, notice that the split in Python -- 2 v 3 -- was already painful. And then they have two different versions of each piece software.
<madrik>
And two different package managers -- pip for 2 and another for 3.
<madrik>
But I gather that Python 2 is dying/being killed off.
efm has joined #lisp
knicklux has joined #lisp
knicklux has quit [Client Quit]
<jackdaniel>
as name indicates, that are two differen languages -- that does tell how instable is the ecosystem ;)
<amerlyq>
it's only the question of pushing the responsibility to update all old soft, which will break on update. Either way somebody must do it
<jackdaniel>
s/that does tell/this does tell/
<madrik>
amerlyq: It is of course very labor intensive.
<amerlyq>
When you developing one project and use dynamic package manager -- you are somewhat ~ready~ to fix everything which breaks on each update in any deps API. When you periodically develop many projects... you are not so ~ready~, and do it rarely, after gathering great willpower.
<_death>
as a developer you are responsible for your dependencies and working environment.. there are conflicts that are resolved by taking more responsibility away from the distro
<madrik>
In connection with the discussion about SETQ v SETF the other day, I noted that symbol macros were mentioned. Where would they be used? What problem do they solve?
shifty has joined #lisp
<_death>
madrik: I believe originally they were introduced to make WITH-SLOTS (and WITH-ACCESSORS, I guess) possible
<hsaziz>
makrk: THANK YOU!!! That worked! I actually wasted 2 1/2 hours yesterday wrestling with this.
<madrik>
_death: The main argument I read is that now each developer has to keep in step with security updates. This may seem undesirable, globally taken.
<madrik>
hsaziz: Glad to help. Just to cement this, read about removing and purging in apt/apt-get/aptitude/.
<hsaziz>
The thank you was meant to be addressed to madrik! Thanks to all.
<jackdaniel>
as sombody told: security takes all the fun from hacking
<_death>
madrik: either way you have to keep up with those.. you are responsible for your dependencies.. bad programmers think that by using a third party's update mechanism they are no longer responsible
<pjb>
"Distributions" of which the "package manager" is an essential component, are canned administration. It's the way we've found to let end-users user computer systems that need to be sys-administred (this includes the mere installation of an application).
<pjb>
Basically, users don't get to do manage (ie. control) their own system.
jonatack has quit [Ping timeout: 240 seconds]
<madrik>
jackdaniel: I imagine a lot of consumer-grade firmware in routers/appliance-type devices is left to fend for itself after release.
<pjb>
50 years ago, this administration was performed by people near the users (the *local* sysadmin). But 40 years ago, when Linux started and distributions appeared, this administration became (pre-)performed by distribution makers, for remote users/customers.
<pjb>
The most refined form being Android and iOS…
<_death>
personally I disable all auto-update functionality.. it would not work for my grandmother, but it works for me. auto-updates are also prone to abuse, breakage, and can be a source of uncertainty
<_death>
*would not = would perhaps
<pjb>
My mother called me yesterday because her iPhone was dead. It was actually auto-updating…
<_death>
oh, I inverted the sentence in my head after writing it.. nevermind :)
efm has quit [Ping timeout: 255 seconds]
<pjb>
(I got her BOTH an iPad and an iPhone for those occasions!)
efm has joined #lisp
<amerlyq>
_death: Actually, I find myself more and more disillusioned and tired from configuring system for myself as time passes. It was fun very-very long ago, and now it's simply painful. I glad somebody can do it for me so I could focus on problem at hand, despite shedding bloody tears from all the distro bugs which I fixed myself in the past.
<_death>
as a developer you want to maintain a controlled environment and not have changes suddenly appearing without your own knowledge
<_death>
amerlyq: I guess mileage varies ;)
<madrik>
I do wish that more people understood computers, if only to better do their own work, but I see that a lot of people just are not technically inclined.
<madrik>
Nowadays, I taught my Android phone not to tell me when things are updated.
<madrik>
It's useless, more so that changelogs are virtually uninformative
<madrik>
"Security and performance improvements" tells me nothing.
<amerlyq>
Yep, "Security of your device was enhanced". You got to download 1GB of Samsung bloatware updates.
<_death>
on mobile devices, auto-updates have been used to remove features, add malware (ads, tracking, etc.), and generally further exploit an established user base
<amerlyq>
You forgot to add "break things"
<_death>
but even simple look & feel changes make auto-update a bad idea.. this is by the way why I no longer update my stumpwm
<amerlyq>
like broken google speech synthesis on Android9 when your screen is off despite whitelisting the app
scymtym has quit [Ping timeout: 240 seconds]
<pjb>
_death: amerlyq: yes, but the contradiction, is that you also want up-to-date software, with bug, and security bugs removed as soon as possible. Hence the need for perpertual sysadmin, hence the need for canned sysadmin. Hence macOS/iOS….
<pjb>
The only question is whether you accept a locked system, or if you want to be able to do your own sysadmin on the parts that matter to you.
<pjb>
So Linux + distribution is a good compromise.
<madrik>
And here I was under the belief that everyone deployed pi-hole or equivalent, ran Firefox on desktop and mobile with an artillery of extensions like NoScript and uMatrix, used DuckDuckGo, etc.
<amerlyq>
>>> as if it's some dude's personal project
<amerlyq>
You will be surprise to find out, that... it's actually is :)
ljavorsk has quit [Ping timeout: 240 seconds]
<_death>
amerlyq: it used to be.. then some other dudes started developing & using it.. but recently one of the new dudes started making weird changes and the other dudes merged his changes..
<_death>
so this dude stopped updating :)
<madrik>
_death: Reminds of the awful time in Debian with avconv, the ffmpeg fork.
<madrik>
They even had a message saying that ffmpeg was deprecated
<pjb>
systemd….
<amerlyq>
madrik: the more I got tired from complexity of literally broken world, the more I think to go the https://suckless.org way and use bare kernel plus 10 apps ~2000+ lines compiled from sources, which I know absolutely. Simply don't accept madness of external world into your own small isolated paradise for retired geeks.
<pjb>
Exactly. or LFS.
<_death>
or CL :)
<madrik>
pjb: How did older systems like Multics or Genera handle this lower-level plumbing?
<pjb>
10 apps you're counting large. I use basically 2, a web browser and emacs. Ok, add 2 or 3 more apps, and the rest is basic unix CLI stuff I compile myself.
<pjb>
madrik: they just had sysadmin.
shka_ has quit [Ping timeout: 255 seconds]
<pjb>
TEAMS of sysdamins!
shka_ has joined #lisp
<pjb>
Well, not Genera. Genera I guess was more like early PC, where the sysadmin was performed by sophisticated users.
<amerlyq>
>>> new dudes started making weird changes and the other dudes merged his changes
<pjb>
And Genera is a developer system anyways, so…
<amerlyq>
It's a pitiful, but the only way for FOSS to exist. Evolve or die. ZeroMQ/P.Hintjens books and nanomsg postmortem are nice read on topic.
<madrik>
Heh, nice. But I mean, what was the analog of systemd/launchd?
<pjb>
amerlyq: the assumption of FOSS is that users are developers that will inspect, modify and compile themselves their program from sources. Or hire a developer to do it for them.
<_death>
amerlyq: this is wrong.. stumpwm is meant to be customizable software.. this means there's no need to change the default look & feel for everyone, every time you feel like something's wrong
<pjb>
amerlyq: the answer of people is clear, AAPL >$1B FSF ~= $0.
<pjb>
(even if RedHat CEO became IBM CEO, but that's more the fault of IBM than anything else).
<_death>
amerlyq: those recent changes should belong in someone's ~/.stumpwmrc or maybe his own fork, but they should not belong to upstream
<_death>
the same goes to all customizable software, including programming language implementations and their specifications btw
<amerlyq>
"personal customizable software" -- you fork whatever version you like and freeze it / customize yourself. If project looses "pulse of life" maintained even through adding maddening/unrelated changes, it stales. Changes attract new people despite losing some people -- you simply must not lose faster than you attract. Contradictory by itself, but people love "living" soft, not stale one. Therefore
<pjb>
madrik: very simple. The kernel forks the process ID 1 (hardwired or parameter to the kernel in the boot) /bin/init. The /bin/init program initialize some stuff, and runs the script /etc/rc (which runs the script /etc/rc.local), then it reaps orphaned children.
<amerlyq>
Lisp is somewhat odd one.
<_death>
stability is frequently underrated, but here in Lisp-land we have a more balanced view.. shame that some projects are affected by new blood bringing alien values
shka_ has quit [Quit: Konversation terminated!]
FreeBirdLjj has quit [Remote host closed the connection]
<pjb>
madrik: sysv added already some complications with /etc/init.d/rc.* and interdependent service rc files with boot levels…
FreeBirdLjj has joined #lisp
<pjb>
madrik: you could install yourself a LFS for the fun. It'd take a rainy Sunday. You can do that in a VM…
<_death>
amerlyq: freezing is an extreme that is usually unnecessary in Lisp-land.. if someone wants to keep injecting software with changes, usually the way is to fork it (see slime vs. sly).. in this case, the stability profile of a project changed
<amerlyq>
_death: But... how your project will go on living, if you lose personal interest in maintaining it? Nobody will resurrect your code staled for 10+ years for them to continue -- they will better write their own, worse alternative. But if it still struggled through somebody's efforts in whatever form -- they would choose it and continue your project.
<_death>
amerlyq: not sure what you're getting at.. people "resurrect" Lisp code all the time..
<_death>
amerlyq: because we have a stable language, it's easy
<amerlyq>
Yep, Lisp is odd. That's nice.
<pjb>
Indeed. A big difficulty when you want to use old code, is to locate old compilers and old libraries to compile it…
<pjb>
Not so with CL.
<_death>
just recently Xach resurrected a system from the 70s, I think.. OPS5
FreeBirdLjj has quit [Ping timeout: 245 seconds]
<amerlyq>
People often has misconception of "obsolete code". Psychology, nothing more. Unrelated to tools and efforts.
<_death>
oh, 80s
<amerlyq>
By the way, on the lane of complexity: Is there any powerful language even more simple than Lisp, worth learning? I find myself dizzy from complexities of C++/Rust/Haskell/Erlang/J/Perl/Zsh and even Python and return to Lisp again and again despite innumerable years spent on them. Lisp is simple and nice, but I constantly miss... something intangible. Powerful static typesystem? Transparent debugging
<amerlyq>
facilities? System level integration? All languages are only disfigured compromises, even Lisp :(
<pjb>
amerlyq: FORTH, Prolog, APL, Smalltalk.
shka_ has joined #lisp
<pjb>
amerlyq: Eiffel and Modula-3 are nice too.
gravicappa has quit [Ping timeout: 265 seconds]
<amerlyq>
yep, I catch myself thinking they aren't bad to try after all. But... is it worth it nowadays? At least for pet-projects? That's the question.
amnesia__ has joined #lisp
<pjb>
amerlyq: it's interesting to learn them, because when you're a lisp programmer, you can apply different programming paradygms in the same lisp program.
<hsaziz>
Is there an easy to follow tutorial, on using the Lisp debugger or trace?
amnesia_ has quit [Ping timeout: 255 seconds]
<hsaziz>
Also which debugger is easiest, and most intuitive to use? I realize they are usually attached to their individual compiler/REPL.
<amerlyq>
pjb: Mmm, it's more about "ultimate simplicity" or "intuitive reasoning", and not "even more paradigms to add to this boiling hell". I can reason for hours about monads and then restructure whole codebase in the name of pursuing intangible but important benefits, but... it isn't worth it for anybody reading my code -- because all these subtleties made it even harder to understand.
<amerlyq>
and then nobody can maintain/evolve codebase in the same way, I originally pursued.
Involuntary has joined #lisp
Jeanne-Kamikaze has quit [Ping timeout: 240 seconds]
ebrasca has quit [Remote host closed the connection]
hsaziz has quit [Ping timeout: 258 seconds]
jonatack has joined #lisp
<pjb>
amerlyq: an important idea of lisp programming is that you write your code in terms of the solution. Basically, you just write a sexp that "express" the solution in terms of the domain. Then, you implement the data types and operators needed to make this sexp run in lisp.
<pjb>
amerlyq: If a solution is a one-liner expression of monad, then just do that! If it's a one-liner APL, do it. If it's a one-liner prolog, do it. (or just a few tens of lines).
<amerlyq>
pjb: you have a point. A strong point for CS-educated workforce, which knows subtleties why from 1000 funcs/vars you must prefer this hundred over that hundred, or optimize cache lines for x86_64 arch performance, or etc. But then you deal with... not so educated or highly opinionated deluded people. And they are looking into the same codebase but don't see what you see. They see smth different, and
<amerlyq>
therefore evolve it differently.
slyrus_ has quit [Ping timeout: 255 seconds]
EvW has joined #lisp
<amerlyq>
By any means I'm not justifying even more verbose language to declare everything explicitly. And maybe Lisp is the closest and cleanest thing we can get to express nested abstractions and their intuitive transition on code evolution. But vaguely it still feels... not right there.
shka_ has quit [Ping timeout: 272 seconds]
<amerlyq>
Maybe... the main problem we don't have an "single abstract language to describe abstractions" like Math does, so everybody could speak the same language and naturally "learn" new things on the foundations of previous ones. Instead we have memorized patterns, idioms, cool hacks, dirty hacks... We call some bunch of lines as "AAA idiom" and we can spot it in code (but others cannot). There is no way
<amerlyq>
to teach the language itself to have it (Lisp has the least problems here, actually). And therefore everybody is forced to learn multiple languages at the same time -- Lisp, Math, CS, "common sense", etc. resulting in fragmented and incompatible comprehension.
<p_l>
I'd argue that Math doesn't have single abstract language either, but there's enough of commonly accepted one that people can get through to the point of defining new ones
<Odin->
There's a lot of fragmentation in various subfields there, yeah.
<Odin->
I don't think lambda calculus makes much sense to mathematicians who haven't encountered it before, for instance.
<amerlyq>
Yep, anyway, pjb, thanks for links, it was interesting to skim through.
<amerlyq>
Oh, in continuation to the topic of handling the complexity: how your cognitive load fares on large Lisp systems over >100 classes and >1000 functions?
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
<amerlyq>
What I mean is: it's easy to prove each small function is correct in Haskell by using typesystem, and it's easy to prove it's correct by playing with it in Lisp interactively. But to prove the system as whole is still doing what you expect (vaguely fantasize) it to do -- how hard it actually is?
<amerlyq>
I often observe myself being slightly lost and only 99% sure I know how my 50+ functions in module actually interact. With Haskell I top it by 99.9% sureness -- depending on correct (and verbose) types. But this remaining 1% is unnerving.
<pjb>
amerlyq: wrong. It's not easy to prove a function is correct in Haskell. What the type system is an easy way to prove it's NOT correct in some specific way.
<pjb>
amerlyq: it cannot prove it's NOT correct in important other ways, and it definitely cannot prove it's correct.
fanta1 has quit [Quit: fanta1]
<amerlyq>
at least it helped immeasurably to spot "accidentally broken" things on scale of practicality.
<pjb>
amerlyq: 100 classes, 1000 functions is nothing. Android was 3500+ classes, * 1000+ methods ten years ago. Imagine the size of it now!
<amerlyq>
and with Lisp I constantly feel like I may broke something which I already forgot
<amerlyq>
I talk about pure CL systems. I don't dare to even tread that Android mess.
<pjb>
amerlyq: have a look at ACL2 (theorem prove written in CL and embedded in (a subset of) CL.
<pjb>
amerlyq: you can write algorithms and ACL2, and see how it feels to use a more abstract programming system.
<amerlyq>
is it practical for everyday use?
<pjb>
If your everyday job is to write proven programs, yes.
<pjb>
amerlyq: there are already AI that debug programs (at the cost of $8/hour of AWS).
<pjb>
amerlyq: you could implement one such AI for Lisp programs, and fear not anymore to break anything which you forgot…
<amerlyq>
I would liked to see how it will debug concurrently smashed stack under Java/JNI coredump
torbo has joined #lisp
GuerrillaMonkey has joined #lisp
shka_ has joined #lisp
<amerlyq>
Question is more about "human cognitive load" and how everybody cope with it. When I write several large functions, I can "control" how these functions interact between themselves, but all "chaos" is hidden inside these functions and break their contracts occasionally. When I write large amount of very small functions -- each one is crystal clear, but now "chaos" is hidden in-between all these
<amerlyq>
functions, it's ephemeral and even harder to debug when something is wrong. If you use optimal size of each function and their amount... you simply convert complexity to maintaining fragile stability.
<pjb>
amerlyq: on InterLisp there was such a programmer assistant.
<pjb>
It would comment on your code, and detect bugs.
<amerlyq>
Maybe systems in the time of InterLisp were less complex, less concurrent and less multi-functional~ ? :)
shifty has quit [Ping timeout: 265 seconds]
shifty has joined #lisp
<pjb>
May be AI had much less resources in the time of InterLisp, and nowadays you could tap the resources of Amazon, Google, Internet and the cloud to make something way more intelligent!
<pjb>
amerlyq: there's also code generation AI, so you don't even have to write the code yourself! Just describe your domain.
torbo has quit [Remote host closed the connection]
torbo has joined #lisp
krwq has joined #lisp
<amerlyq>
you meant "write even more complex and uncontrollable mess" :) I somehow relate to V.Vinge "A Deepness in the Sky" vision of future of "broken layers over broken layers of software". Ok, lets wait until AI will consolidate everything and salvage everybody... in some unacceptable ways :)
troydm has joined #lisp
<pjb>
amerlyq: apply this AI mess to itself to clean it up!
<amerlyq>
Yep, it's exactly what I meant by "consolidate everything". And as humans are the main factor for creating more and more chaos inside resulting system... there is the obvious way to fix it for AI.
<_death>
we're in another AI winter.. it's been reduced to function fitting
<_death>
giving what the industry does with it, it's for the best..
<_death>
*given
hsaziz has joined #lisp
<amerlyq>
Is there any small but nice example of extensive use of typesystem in Lisp? Most libs I see are fit into two extremities -- very weak typesystem usage, or very complex by itself to see through.
prince1 has joined #lisp
hsaziz has quit [Ping timeout: 258 seconds]
Inline has quit [Ping timeout: 272 seconds]
narimiran has quit [Ping timeout: 260 seconds]
shka_ has quit [Ping timeout: 240 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
prince1 has quit [Ping timeout: 258 seconds]
v0|d has quit [Remote host closed the connection]
Inline has joined #lisp
stepnem has quit [Ping timeout: 265 seconds]
stepnem has joined #lisp
ljavorsk has joined #lisp
shifty has quit [Ping timeout: 258 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
sjl has joined #lisp
scymtym has joined #lisp
hiroaki_ has quit [Ping timeout: 272 seconds]
v0|d has joined #lisp
ljavorsk has quit [Ping timeout: 265 seconds]
krwq has quit [Remote host closed the connection]
v0|d has quit [Remote host closed the connection]
z147 has joined #lisp
random-nick has quit [Ping timeout: 265 seconds]
jonatack has quit [Ping timeout: 240 seconds]
prince1 has joined #lisp
v0|d has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]