<piethesailor>
I am having a headache trying to get it running on my new machine
<piethesailor>
I have quickloaded the cl-selenium repo and installed google-chrome-stable plus selenium-server-standalone.jar
JeromeLon has quit [Quit: WeeChat 3.5]
<piethesailor>
selenium standalone is 3.14 and chrome-stable is 121
<piethesailor>
is that a version mismatch? do I need another program in there somewhere? any help would be appreciated
<piethesailor>
Honestly this is probably way to complex for asking here in hindsight. quickloading cl-selenium also throws an error that it cant find libcrypto.so though I have openssl. it also complains about other issues I havent had before.. Wish I took notes the last time I got it up and running lol
random-nick has quit [Ping timeout: 260 seconds]
josrr has quit [Remote host closed the connection]
ymir has quit [Ping timeout: 252 seconds]
piethesailor has quit [Remote host closed the connection]
decweb has joined #commonlisp
piethesailor has joined #commonlisp
Inline has joined #commonlisp
meritamen has joined #commonlisp
pfdietz has joined #commonlisp
ymir has joined #commonlisp
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
semz has joined #commonlisp
brokkoli_origin has quit [Quit: (Leaving)]
decweb has quit [Ping timeout: 256 seconds]
Inline has quit [Quit: Leaving]
Inline has joined #commonlisp
Inline has quit [Quit: Leaving]
meritamen has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
waleee has quit [Ping timeout: 252 seconds]
Inline has joined #commonlisp
Inline has quit [Ping timeout: 240 seconds]
brokkoli_origin has joined #commonlisp
Lycurgus has quit [Quit: leaving]
decweb has joined #commonlisp
thuna` has quit [Read error: Connection reset by peer]
tyson2 has joined #commonlisp
brokkoli_origin has quit [Ping timeout: 268 seconds]
rtypo has quit [Ping timeout: 255 seconds]
piethesailor has quit [Ping timeout: 256 seconds]
brokkoli_origin has joined #commonlisp
<BrokenCog>
so, I'm trying to figure out packages. I wrote a lib to use in an app. the lib has (defpackage :mylib (:use :cl) (:export :functions)). However, I'm confused about where to use packages used by the lib? (:use :cl :dexador) throws an error that Dexador isn't known. I already have mylib.asd with a :depends-on (:dexador) statement.
villageidiot has joined #commonlisp
<BrokenCog>
if I use the lib via the app (ql:quickload 'mylib) things work fine.
<beach>
BrokenCog: I am not sure I understand the problem.
<beach>
BrokenCog: Part of the problem is that you have the same name for a system and for a package. I think that will make you more confused.
<beach>
BrokenCog: Like (ql:quickload 'mylib) will load a system. If that system creates your MYLIB package when loaded, then it should be usable afterwards. When is the MYLIB package not created?
<beach>
BrokenCog: And I don't understand what you mean by "where to use packages used by the lib". I mean, if they are "used by the lib" then that's where you use them, no?
<beach>
clothespin: You can't get SICL to run, because it is not finished.
<BrokenCog>
beach: I don't follow what's the same name of a package and a system? which name?
<beach>
When you do (ASDF:DEFSYSTEM ...) you define a system. And quickload loads systems.
<BrokenCog>
okay, that's in the asd file.
<beach>
Yes.
<BrokenCog>
should that be a different name than the actual package?
<BrokenCog>
mylib.asd mypackagelib.lisp??
<beach>
They can be the same, but right now I think you are confused because the names are the same.
<BrokenCog>
maybe. to simplify, I don't need asdf or quicklisp for this: they're in my local directory where I'm working. In wchih case I can get rid of the asd file, would anything else need to change?
<beach>
If your code depends on other systems, perhaps in Quicklisp, you create yourself an ASDF system definition, and you put the other systems in :DEPENDS-ON.
<BrokenCog>
:depends-on ("dexador" "jsown")
<beach>
If you don't need Quicklisp or ASDF, then you can just LOAD your files into your Common Lisp image. But you seem to need those two system, so if you don't have an ASDF system definition, you need to load those systems manually first each time you have a new Common Lisp image.
<BrokenCog>
I get that. I was saying not use them to understand the different components. So, currently, in the repl (ql:quickload 'mylib) loads. The problem is in Emacs, slime-eval-buffer (using the same REPL as previously) fails with "Dexador not loaded" or something. Unless I quickload the lib first into the repl ... then the eval of the buffer succeeds ... because it's loaded already.
<BrokenCog>
is that just normal workflow? or have I configured the package wrong? that's what I"m trying to figure out,.
<aeth>
BrokenCog: packages are just namespaces for symbols and are not a good name for what they are, although unfortunately there's a separate concept of "namespaces" that already exists with that name (that variables and functions and types, among other things, are all in different "namespaces" so you can have both a function foo and a variable foo)
<beach>
aeth: You want to take over? Go ahead!
<BrokenCog>
aeth: right, I understand. Hence the 'system' label in ASDF.
<beach>
BrokenCog: The normal workflow is, you start up your Common Lisp image and at the repl, you load the system you are interested in. After that, you should be able to use SLIME to evaluate arbitrary code using SLIME-EVAL-BUFFER.
<aeth>
BrokenCog: if you are having an issue running your file unless you quickload something first, then you haven't configured your .ASD file properly and you're not loading a dependency that you need to load
<kagevf>
I think you have to quickload the other system, if you're not setting up an .asd file like beach described.
<aeth>
that is, you only need to quickload one thing, your system, not any dependencies
<aeth>
you don't have to do this, you can just quickload all of your dependencies, but this is annoying and basically only happens in a small one-off script file
<BrokenCog>
okay. I just wasn't realizing that I need to initially populate the repl - I was thinkking that slime was going to do that. If I load it first (via QL) then slime works.
<aeth>
(ql:quickload :your-thing)
<aeth>
which should load the rest.
<BrokenCog>
right. it does. as long as I do tha tin the repl first.
<BrokenCog>
and then go use it within slime.
<beach>
BrokenCog: You don't "populate the repl". You have a single Common Lisp image that SLIME interacts with, and that image needs to have some initial things loaded.
<BrokenCog>
loading into the repl ... populating the repl ... you'll have to explain the semantic difference with that verbiage.
igemnace has joined #commonlisp
<beach>
You don't load into the repl either. You use the REPL to load things into your running Common Lisp image.
<beach>
That image is then what both the REPL and SLIME interact with.
<BrokenCog>
okay, so, even more idiomatically similar to 'populate'
<beach>
You can use "populate" if you will, but you don't "populate the REPL", you use the REPL to "populate" your Common Lisp image.
<BrokenCog>
ah, okay. that makes sense.
<kagevf>
it's a good idea to stick with the established terms so everyone knows what everyone else is talking about with minimum ambiguity
<BrokenCog>
sure.
<beach>
kagevf: I can't agree more.
<aeth>
And you don't have to use the REPL, either. You could do it in a script that basically runs the exact same commands (a quickload and then a function call to an entry point function). This could be how you deploy it, but isn't how you develop it. It's all about the CL image.
<aeth>
You can even save the image, etc. It's almost Smalltalk-ish...
<beach>
I don't think BrokenCog needs lots of alternative ways right now. One way that works is probably quite enough.
<aeth>
I'm just trying to say that the REPL is just the most convenient (interactive) way to develop, but what's really the thing going on is an image.
<BrokenCog>
right. That's how I have historically worked. mainly because I didn't want to deal with SLIME, but, time for upgrade.
occ has quit [Ping timeout: 252 seconds]
<beach>
BrokenCog: All that SLIME does when you do slime-compile-... is to send the code to the Common Lisp image to be evaluated or compiled. It can't know about the systems you depend on in order to work.
<BrokenCog>
I get that now.
<beach>
Great!
<BrokenCog>
thanks for the help.
<beach>
Pleasure. Good luck!
<aeth>
BrokenCog: the system definition tells the image which files to load and in which order so you produce the side effects that you want. The end result, of course, is to produce packages:symbols that you can use (call if a function; or, if not, somehow otherwise depend on)
<aeth>
Without this sort of thing, you could in principle just have one image that constantly lives and evolves, but then how do you get back to that state?
occ has joined #commonlisp
decweb has quit [Ping timeout: 264 seconds]
tyson2 has quit [Remote host closed the connection]
meritamen has joined #commonlisp
Inline has joined #commonlisp
<beach>
aeth: That's what I would like to fix with first-class global environments. Then you would not need to restart your image, but you could still create a new global environment if you want to create your state from scratch.
<beach>
"What's the difference?" you might ask. Well, if you have an IDE running as well, if you restart the image, then you have to quit the IDE as well. Not so, if you just recreate a first-class global environment.
villageidiot has quit [Quit: Client closed]
hoolahoop has joined #commonlisp
hoolahoop has quit [Read error: Connection reset by peer]
ox7b97 has joined #commonlisp
<beach>
In fact, you can argue that current Common Lisp implementations are not very well suited for an IDE running in the same image, because it is way too easy to make the image unusable, even with safe code.
<aeth>
beach: I assume that any current CL editor would behave exactly like SLIME in Emacs with an inferior-lisp and swank.
<aeth>
Not just to avoid the restarting issue, but also because package conflicts could exist with the editor itself and with whatever you are working on (perhaps a different version of the editor itself!)
<beach>
aeth: If by "current CL editor" you mean existing ones, I suppose that would have to be the case, yes.
<beach>
But with first-class global environments, that problem disappears.
jmdaemon has quit [Ping timeout: 240 seconds]
pfdietz has quit [Quit: Client closed]
bubblegum has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 252 seconds]
bubblegum has joined #commonlisp
chomwitt has joined #commonlisp
msavoritias has joined #commonlisp
wacki has joined #commonlisp
Inline has joined #commonlisp
Lycurgus has joined #commonlisp
<beach>
I haven't followed the development of Lem. Does it use SWANK or something similar?
pfdietz has joined #commonlisp
chomwitt has quit [Ping timeout: 256 seconds]
Gleefre has quit [Remote host closed the connection]
Pixel_Outlaw has quit [Quit: Leaving]
msavoritias has quit [Remote host closed the connection]
msavoritias has joined #commonlisp
ox7b97 has quit [Ping timeout: 264 seconds]
Inline has quit [Ping timeout: 264 seconds]
pfdietz has quit [Quit: Client closed]
ox7b97 has joined #commonlisp
jonatack has quit [Ping timeout: 276 seconds]
amb007 has quit [Ping timeout: 264 seconds]
ox7b97 has quit [Ping timeout: 268 seconds]
ox7b97 has joined #commonlisp
occ has quit [Ping timeout: 264 seconds]
ymir has quit [Ping timeout: 255 seconds]
ox7b97 has quit [Ping timeout: 260 seconds]
treflip has joined #commonlisp
pve has joined #commonlisp
zetef has joined #commonlisp
ox7b97 has joined #commonlisp
amb007 has joined #commonlisp
ox7b97 has quit [Ping timeout: 276 seconds]
rgherdt has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
ox7b97 has joined #commonlisp
ox7b97 has quit [Ping timeout: 260 seconds]
tok has joined #commonlisp
shka has joined #commonlisp
ox7b97 has joined #commonlisp
zetef has quit [Ping timeout: 264 seconds]
ox7b97 has quit [Ping timeout: 268 seconds]
bendersteed has joined #commonlisp
Lycurgus has quit [Quit: leaving]
Cymew has joined #commonlisp
ox7b97 has joined #commonlisp
ox7b97 has quit [Ping timeout: 264 seconds]
danse-nr3 has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
dcb has quit [Quit: Connection closed for inactivity]
zetef has joined #commonlisp
mm007emko has joined #commonlisp
ox7b97 has joined #commonlisp
meritamen has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ox7b97 has quit [Ping timeout: 268 seconds]
amb007 has quit [Ping timeout: 264 seconds]
traidare has joined #commonlisp
amb007 has joined #commonlisp
msavoritias has quit [Ping timeout: 264 seconds]
dino_tutter has joined #commonlisp
mgl has joined #commonlisp
zetef has quit [Ping timeout: 260 seconds]
zetef has joined #commonlisp
zetef has quit [Ping timeout: 255 seconds]
Inline has joined #commonlisp
Inline has quit [Ping timeout: 264 seconds]
X-Scale has joined #commonlisp
occ has joined #commonlisp
amb007 has quit [Ping timeout: 268 seconds]
bubblegum has quit [Remote host closed the connection]
Inline has joined #commonlisp
bubblegum has joined #commonlisp
dnhester has quit [Remote host closed the connection]
dnhester has joined #commonlisp
X-Scale has quit [Quit: Client closed]
Alfr has quit [Ping timeout: 256 seconds]
Inline has quit [Ping timeout: 264 seconds]
Inline has joined #commonlisp
X-Scale has joined #commonlisp
Inline has quit [Client Quit]
Inline has joined #commonlisp
zetef has joined #commonlisp
donleo has joined #commonlisp
Inline has quit [Ping timeout: 260 seconds]
Inline has joined #commonlisp
zetef has quit [Remote host closed the connection]
azimut has quit [Ping timeout: 255 seconds]
treflip has quit [Ping timeout: 276 seconds]
tok has quit [Ping timeout: 246 seconds]
tok` has joined #commonlisp
tok` has quit [Changing host]
tok has joined #commonlisp
occ has quit [Read error: Connection reset by peer]
Gleefre has joined #commonlisp
OlCe` has quit [Remote host closed the connection]
beach` has joined #commonlisp
Inline has quit [Ping timeout: 256 seconds]
beach has quit [Killed (NickServ (GHOST command used by beach`!~user@2a01:cb19:f97:cd00:2d76:1155:1c7e:6337))]
beach` is now known as beach
Inline has joined #commonlisp
dnhester has quit [Remote host closed the connection]
dnhester` has quit [Read error: Connection reset by peer]
rendar has joined #commonlisp
kevingal has joined #commonlisp
kevingal_ has joined #commonlisp
markb1 has quit [Ping timeout: 255 seconds]
markb1 has joined #commonlisp
<splittist>
beach: I believe LEM uses Swank. It can use LSP for other languages.
danse-nr3 has quit [Read error: Connection reset by peer]
danse-nr3 has joined #commonlisp
<beach>
I see. Thanks!
kurfen_ has joined #commonlisp
kurfen has quit [Ping timeout: 255 seconds]
random-nick has joined #commonlisp
occ has joined #commonlisp
OlCe` has joined #commonlisp
msavoritias has joined #commonlisp
Inline has quit [Ping timeout: 268 seconds]
Alfr has joined #commonlisp
danse-nr3 has quit [Ping timeout: 264 seconds]
varjag has joined #commonlisp
varjag has quit [Remote host closed the connection]
varjag has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
Gleefre has joined #commonlisp
varjag has quit [Ping timeout: 246 seconds]
treflip has joined #commonlisp
Inline has joined #commonlisp
Inline has quit [Ping timeout: 276 seconds]
varjag has joined #commonlisp
treflip has quit [Quit: Quit]
danse-nr3 has joined #commonlisp
mal1 is now known as lieven
dnhester has joined #commonlisp
<Kingsy>
I have a question around project structure, if someone could offer some advice. I am coming from a background of java and php. so I am struggling to understand how to properly achieve seperation of concerns because in CL a class is a object really, and a method is something that is totally separated but has the notion of that object. this means that the dependency pattern for service based application
<Kingsy>
architecture is not possible right? because if a method is created in a package ALL other functions or code in that package knows about the method.
<Kingsy>
amd I mad here? would be good to chat about best practice.
<beach>
Kingsy: You use the package system for the encapsulation part of what a Java class does, and you use classes for the representation parts.
mm007emko has quit [Quit: Client closed]
<Kingsy>
beach: but if you did that. don't you end up with a really complicated and use package / asd definition? you would be creating a new package for every type? or every entity / model?
<beach>
Kingsy: So you could emulate what Java does by having one package for each class, but that is exaggerated.
<Kingsy>
you would end up with 500 packages
<beach>
Yes, you don't need that.
<Kingsy>
beach: but if you don't do that, which is kinda what I am doing now, let me explain what I have done for context.
<beach>
Uh, oh.
<Kingsy>
hahaah its not that bad just setting the scene
<beach>
Yes, but I very likely won't understand it.
<Kingsy>
I have a little framework of sorts I am building to learn CL. so I have a core package, a data package, a service package and a main package. each of them was designed to just encapsulate logic that the other packages mostly swhouldnt be exposed mto. which is all fine!
<Kingsy>
but once we start to write code. lets say in the service package, and we want to create some functions that grab items from the data package (using an exposed function) and change it. every single item that goes into that package is known by everything else in the package. which to me breaks seperation of concerns. you might have a group of functions that are responsbile for building something specific
<Kingsy>
and you cant ghroup them. if someone comes along and adds to the file they will see not a few classes but potentially hundreds or even thousands of functions in a big soup
<beach>
I tend to use one package more or less per protocol (i.e., generalization of interface). Certainly not one package per class.
<Kingsy>
yeah I feel like thats what I am trying
<Kingsy>
but don't you end up with a function / method soup?
<beach>
No.
<beach>
You can study something like Cluffer. I am fairly satisfied with its structure.
<beach>
There you can see how classes and packages are used.
<beach>
... and Cluffer is not very big either.
decweb has joined #commonlisp
<Kingsy>
yeah I feel this is similar to what I have just packages that generally encapsulate application layers. I just find it reallyt weird that everything in the package can interact with everything else. there are no private functions for example.
<beach>
I think the fine-grained encapsulation in traditional object-oriented languages is probably the reason why code using such languages get very complex very fast.
<beach>
... and why many people now move away from object-oriented programming. They just don't know that there is something better.
<Kingsy>
yeah I can see that tbh. I do see the advantage of freedom, but with this you would have to be so careful it doesnt get messy. so are we saying that seperation of concerns to acheived by just putting methods / functions into files that group and just assume that any other devs know these other functions are not fit for purpose using a naming convention?
* beach
needs to vanish a while. Perhaps others can answer.
<Kingsy>
beach: I apprecate your answers and you taking the time. thanks
X-Scale has quit [Quit: Client closed]
green_ has quit [Ping timeout: 264 seconds]
<splittist>
While Common Lisp has been (and is being) used to build complex stuff, I think it is the problem being solved that is complex, not the organization doing the building. So it doesn't really provide the facilities for a setup whereby you want people to write software but don't actually trust them to do it properly.
bubblegum has quit [Remote host closed the connection]
son0p has quit [Quit: Bye]
bubblegum has joined #commonlisp
meritamen has joined #commonlisp
yitzi has joined #commonlisp
mm007emko has joined #commonlisp
attila_lendvai_ has joined #commonlisp
<mm007emko>
Kingsy, in PHP you can also have free standing functions in "something.php" files, you can have there classes. In Common Lisp, I dare to say, you use object system (CLOS) if it helps you with design of your program but if you don't have to, just free standing functions (encapsulated in packages) and simpler datastructures (lists, maps...) will do
<mm007emko>
just fine.
meritamen has quit [Remote host closed the connection]
tok has quit [Remote host closed the connection]
<beach>
Yes, splittist has a good point.
Odin-LAP has quit [Read error: Connection reset by peer]
donlcn has joined #commonlisp
epony has quit [Remote host closed the connection]
donleo has quit [Ping timeout: 260 seconds]
son0p has joined #commonlisp
Odin- has quit [Ping timeout: 255 seconds]
<Kingsy>
splittist: its true. but its about the language offering tools we can use to help manage complex solutions.
epony has joined #commonlisp
<Kingsy>
mm007emko: you can but lets just say you have a complex solution, how do you protect against the ideas of a function being used for something it shouldnt be? the only way is to abstract it into another package. its not possible to do it within a package.
<Kingsy>
which means you cant have a thing, lets say an entity, and some internal functions that manipulate that entity and just hide and abstract that from the rest of the package and the other entities
<Kingsy>
everything knows about everything else.
epony has quit [Excess Flood]
<mm007emko>
Within package in Common Lisp, yes, everything knows about everything. When you use it from other package, you typically use only exported functions (these would be public methods).
epony has joined #commonlisp
dra has joined #commonlisp
dra has quit [Changing host]
dra has joined #commonlisp
josrr has joined #commonlisp
<Kingsy>
yes, which means me think about overall structure. if you wanted to have internal functions for "things" in a package, you either need to commit to a package where every object COULD touch everything else, or you have a tonne of packages. there is nothing in the middle, which is taking me some time to get my head around if I am structuring my projects correctly.
epony has quit [Client Quit]
<Kingsy>
I would if anyone has thought about using macros to try and make common lisp similar to java, in terms of defpackge for you and a body space to allow you to create a class and functions all within that space? are tehre any overheads to a shed load of packages?
<ixelp>
Programming in the Large: Packages and Symbols
<dnhester>
Basically you develop modules, sure, in a package it ends up much larger than it would be in say java, or python, but then it's a self contained functionality that matters, like an independent system
epony has joined #commonlisp
<dnhester>
then you build a large project by bringing together different modules. the awesome part is that basically the modules are independent of each other
<dnhester>
I was thinking of making a module independent of the project and realized I can just move the folder out... didn't even have to change the asd file, no code was changed even though I moved a folder full of files with about 2000 lines of code
<Kingsy>
well to some extent. there are exports and imports usually right? which means a package usually wouldnt work without another?
<dnhester>
it just worked they way it was, and I realized I could already use that code in other projects
<Kingsy>
dnhester: doesnt the asd file name the files for each component?
<dnhester>
pretty much unless you are coding a module that depends on another module specific to your project, the functionality should be independent
<Kingsy>
dnhester: agreed but you couldnt move the package out, the asd would be referencing files that didnt exist anymore.
<mm007emko>
This is not really different from other non-OOP languages. I definitely didn't try to make Common Lisp similar to Java, I'd actually advise against it. If your program can benefit from OOP, use CLOS, that's fine (it's there exactly for this reason, OOP is good for certain things). But languages like Java or C# overuse it even in cases where it
<mm007emko>
makes things just unnecessarily difficult.
<dnhester>
this "module" had it's own asd file, and the large project just had it as a dependency, but not with a hard coded path
<splittist>
Kingsy: how about this: you can have systems, packages and files. While not strictly orthogonal, each of these emphasise a different dimension/axis of organisation. With these tools, there doesn't seem a need for an extra layer of 'namespacing'. But perhaps I don't understand a culture where you say to someone 'work on code in this file, but don't refer to all the functionality therein'.
<dnhester>
The key here is that you are not trying to limit data and functions from each other in the system you are building like in java... here you just decide what your user interface is going to be, export those symbols, and that's it, everything else implementation related is not exported, and there's no reason why inside your system your functions and data should be protected from each other
<Kingsy>
no this is all good information.
<splittist>
Having said that, there are textual conventions like prepending #\% to a symbol, which indicates 'internal'.
<dnhester>
if you need to organize things, just break it up in files, but that's just for you to read... the package is the same
<splittist>
indicates to the human reader, not the compiler.
<dnhester>
again, I would just read cluffer and Eclector and CLIM
<dnhester>
I haven't had a chance to write a guide explaining it, but going through the code should be eye opening
<Kingsy>
so would you say the trade off here is careful development because you need to make sure if there are multiple developers or this is a long running project functions are not just randomly used for loads of different things in different contexts?
dra has quit [Ping timeout: 268 seconds]
<Kingsy>
it puts more on the devs making sure we don't end up with a car crash (spaghetti programming)
<dnhester>
I would say the tradeoff is that you need to think a bit about what is an independent unit of functionality you want to make a system for. Systems shouldn't be so large that you are then worried about conflicts, if so, they can probaby be split into multiple systems
<Kingsy>
i.e if you hvae a function that is private to a class as a dev you know. ok whatever I change here can only be used in this class, so you know the fallout of the changes you make. when you change a function in a package it could change ANY functionality in the package. so you need to know that a dev somewhere else has not used it for something they shouldnt
<Kingsy>
dnhester: yeah this is a fair point.
<Kingsy>
I am just coming from such a OOP background. and this feels so strange. but kinda liberating. its almost like I;m a dog chasing a car, now I have reached it I have no idea what to do with it :D
<dnhester>
the exported symbols from your package should adhere to some sort of contract on what they do. inside your package, you can quickly see every place a function is called by a simple search inside that folder...
<Kingsy>
dnhester: the big thing I am seeing about Cluffer is "subsystems" which is something I don't have. IO just have components which point to packages.
<Kingsy>
dnhester: yeah agreed.
<mm007emko>
Kingsy I know that feeling :) . But then, you can just use Java in teams where programmers can't be trusted - it works well in corporate world.
<Kingsy>
dnhester: ahah I am kinda scared that if I get into this I am going to start to dislike languages with heavy emphasis on OOP :D :D
<mm007emko>
Don't worry. You won't dislike them. You will despise them.
<dnhester>
It's fairly small, it's an independent unit of functionality, and it's imported by cluffer base...
mgl has quit [Remote host closed the connection]
<Kingsy>
uhm doesnt depends-on mean it controls load sequence with cluffer base and exposes the package so it can be imported? not importing it? the imports are done by the packages?
<Kingsy>
sorry this is probably a dumb question - as I said I am still learning
jonatack has joined #commonlisp
mgl has joined #commonlisp
mgl has quit [Client Quit]
mgl has joined #commonlisp
<splittist>
Kingsy: cluffer-base is a system. The packages defined by cluffer-base will be dealt with in the file in cluffer-standard-line that deals with packages. In this case, 'packages.lisp'.
<splittist>
Kingsy: perhaps I should have said 'The symbols defined'.
<Kingsy>
yes, but cluffer-base doewsnt know about standard-line, but standard-line can use exported symbols from cluffer-base if they are reference appropriatly in the package?
<splittist>
Kingsy: or even better 'MAY be dealt with'. Because if we actually look at that package we see that the package called 'cluffer-standard-line' only :uses cl. So you can be sure that any symbol referenced in the cluffer-standard-line package either comes from common-lisp or from the cluffer-standard-line packag itself.
<splittist>
Kingsy: yes.
<Kingsy>
yes exactly ok!
<Kingsy>
haha it threw me when dnhester said "and it's imported by cluffer base" <- was thinking I misunderstood how defsystem worked
<splittist>
Kingsy: so in 'classes.lisp' we define a class named with the symbol 'line' that inherits from the class named with the symbol 'cluffer:line'.
<Kingsy>
ah yes I see!
green_ has joined #commonlisp
rtypo has joined #commonlisp
traidare has quit [Ping timeout: 268 seconds]
<splittist>
Kingsy: and in 'edit-protocol-implementation.lisp' we're adding a method to the cluffer:cursor-attached-p generic function, specialised on the 'cursor' class that we create in this system.
<Kingsy>
oh hang on that is strange. where is cluffer:line defined if it has no :cluffer in the use portion of the package?!?
bubblegum has quit [Remote host closed the connection]
<splittist>
Kingsy: There must be, in the system or its definitions, something that exports the symbol 'line' from the 'cluffer' package. And, indeed, if we look at the 'cluffer-base' system, we see a file 'packages.lisp' that defines a package called 'cluffer' and exports a symbol therefrom named 'line'
<Kingsy>
I don't see it. hmm this is confusing. I can see there is a :export #:line in packages.lisp. but that exports the standard-line line class, it doesnt import the cluffer:line class from the base for use.
<splittist>
Kingsy: the export is in the Cluffer/base/packages.lisp file
<Kingsy>
splittist: perhaps I am confused what export does. I thought export takes the defclass line(cluffer:line) object and makes it available for any package that uses standard-line, it doesnt explain where cluffer:line comes from
<splittist>
Kingsy: packages deal with symbols, not classes (or functions, or variables, or constants)
<Kingsy>
sorry I know object is not correct here but hopefully you know what I mean :D
<splittist>
Kingsy: :use-ing is about not wanting to specify the package prefix.
<Kingsy>
splittist: but the package is referencing the class when it exports it
<Kingsy>
splittist: let me ask yoiu this. the defclass line definition there in standard-line is extending cluffer:line, where is cluffer:line defined?
<Kingsy>
haha sorry it was a bit rhetorical. so its defined in base, how can standard-line use a class defined in base without a :use cluffer ?
<dnhester>
Kingsy: sorry I had to step out, will be busy for a while...
<splittist>
See above. Any symbol in the image can be referenced. If it is exported, you can reference it with 'package:symbol'. Even if it is not exported, you can reference it with 'package::symbol'.
<Kingsy>
ahhhh ok I have misunderstood this. I thought :export makes the synbols available, use allows you to use them with package:symbol, and :import allows you to use them from the context of the current package.
<Kingsy>
dnhester: if that is the case, what is use for? items outside of the system?
<Kingsy>
oops sorry that was for splittist
zetef has joined #commonlisp
<splittist>
Kingsy: :use is for not having to specify the package explicitly. Which is why it is common to :use "cl" / "common-lisp" . Otherwise you'd have to say (cl:if (cl:< a b) (cl:print "a" cl:*standard-output*)(....[I'm tired of doing that... (: ))
Gleefre has quit [Remote host closed the connection]
<splittist>
Of course, if you are defining your own versions of 'if', 'print', '<
<splittist>
', then that might be just what you want to do. But that is not super-common.
meritamen has joined #commonlisp
dnhester has quit [Remote host closed the connection]
<splittist>
There are other approaches/styles with packages where :use-ing might be more common. If you have a bunch of utility functions for a system/set of systems, you might have a 'foo-utils' package that you 'use' in all the packages of the system. By putting them in a separate package and :use-ing them, then only the exported symbols get imported into the packages, and all the names of the support functions (for want of a better word)
<splittist>
in the foo-utils package don't leak.
mm007emko has quit [Ping timeout: 250 seconds]
<splittist>
Kingsy: for most purposes, and for most of the time, it just works (TM). The only thing to remember is when you start reorganizing your packages, you're going to want to restart your image (:L
<splittist>
(And all this advice is worth exactly what you are paying for it)
<Kingsy>
splittist: if thats the case (how you described :use) working, what is :import for?
waleee has joined #commonlisp
<Kingsy>
splittist: btw I very much appreciate you discussing this with me. its hugely beneficial for my learning
<splittist>
Kingsy: :import is similar, but it is the importing package that chooses which names it wants to use without the package symbol.
<splittist>
Kingsy: not a great example, but with the 'foo-utils' package, instead of having to :use everything it exports (with :use), you could pick and choose with :import-from.
<Kingsy>
right interesting.
<Kingsy>
splittist: curious, I know you cant limit other code in a package referencing all other code in the package. can you stop some packages using others?
tyson2 has joined #commonlisp
lcn__ has joined #commonlisp
bjorkintosh has quit [Remote host closed the connection]
donlcn has quit [Ping timeout: 240 seconds]
traidare has joined #commonlisp
<beach>
Kingsy: I think you are thinking way too much about disallowing some code from doing certain things.
danse-nr3 has quit [Ping timeout: 260 seconds]
varjag has quit [Ping timeout: 268 seconds]
<beach>
My professor at the university described Lisp as a "lots of rope" language, i.e., give the users lots of rope; if they want to hang themselves, that's their problem.
<beach>
Kingsy: If you could really prevent some code from doing certain things, then you could not write an object inspector or a debugger.
mm007emko has joined #commonlisp
jonatack has quit [Ping timeout: 246 seconds]
szkl has quit [Quit: Connection closed for inactivity]
chomwitt has quit [Remote host closed the connection]
X-Scale has joined #commonlisp
mm007emko has quit [Quit: Client closed]
yitzi has quit [Remote host closed the connection]
ymir has joined #commonlisp
<jcowan>
Kingsy: If you want to hide information, you hide it inside a procedure.
<Kingsy>
jcowan: a procedure?
<jcowan>
a function, sorry
<Kingsy>
jcowan: but anything could call the function?
NotThatRPG has quit [Remote host closed the connection]
NotThatRPG has joined #commonlisp
<jcowan>
yes, but variables defined in the procedure are invisible outside the procedure
dcb has joined #commonlisp
<jcowan>
function, whatever
<Kingsy>
ah right yep got you. so just internal processing for the function. fair enough yep
attila_lendvai_ has quit [Ping timeout: 256 seconds]
piethesailor has joined #commonlisp
chomwitt has joined #commonlisp
a51 has quit [Quit: WeeChat 4.2.1]
olvn has joined #commonlisp
zxcvz has joined #commonlisp
pfdietz has joined #commonlisp
rogersm has joined #commonlisp
anthk_ has quit [Quit: nyaa~]
anthk_ has joined #commonlisp
Gleefre has joined #commonlisp
zetef has quit [Ping timeout: 260 seconds]
bendersteed has quit [Quit: bendersteed]
piethesailor has quit [Remote host closed the connection]
zetef has joined #commonlisp
bjorkintosh has quit [Ping timeout: 260 seconds]
meritamen has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
bjorkintosh has joined #commonlisp
ymir has quit [Ping timeout: 256 seconds]
prokhor has quit [Ping timeout: 276 seconds]
a51 has joined #commonlisp
josrr has quit [Remote host closed the connection]
piethesailor has joined #commonlisp
josrr has joined #commonlisp
jmdaemon has joined #commonlisp
ymir has joined #commonlisp
Cymew has quit [Ping timeout: 240 seconds]
tyson2 has quit [Read error: Connection reset by peer]
traidare has quit [Ping timeout: 268 seconds]
pfdietz has quit [Quit: Client closed]
pfdietz has joined #commonlisp
varjag has quit [Ping timeout: 276 seconds]
jmdaemon has quit [Ping timeout: 268 seconds]
yitzi has joined #commonlisp
<BrokenCog>
beach: going back to last night, how is "first-class global environments" different than saving the desired image and restarting it later?
dnhester has joined #commonlisp
kevingal_ has quit [Ping timeout: 255 seconds]
kevingal has quit [Ping timeout: 255 seconds]
<beach>
BrokenCog: First-class global environments means that there are several global environments in the same image, and one environment can use functions, classes, etc., from other environments.
<beach>
So, for example, in a typical Common Lisp implementation, if you download some code that alters the compiler, you can easily be exposed to malware. By putting the compiler code in a separate environment, and only exposing COMPILE and COMPILE-FILE, the downloaded code would have to switch global environments, and that would presumably be protected by (say) a password.
* beach
apologizes for the dangling participle.
<piethesailor>
Anyone using slynk+nyxt?
<beach>
piethesailor: You might have better luck if you just expose your issue.
<piethesailor>
lol fair enough
<piethesailor>
I can do that
<Demosthenex>
i wish i were hip enough to
<beach>
... unless you just want to invite them for coffee or something.
<piethesailor>
Zoom coffee hangout..
<piethesailor>
I opened up next and started the start-slynk server on port 4006
<beach>
BrokenCog: Makes sense?
<piethesailor>
then ran in emacs sly-connect with localhost and port 4006
<BrokenCog>
beach: your example perfectly. I'll read that PDF later today. thanks!
<beach>
BrokenCog: Pleasure. Feel free to ask more questions if you want.
<anthk_>
piethesailor: no, plain sbcl
<piethesailor>
this opens a NYXT-USER> repl. From here I run in repl (set-url "www.google.com") and in nyxt I get a spinning wheel but nothing happens
<piethesailor>
That is my issues atm
bendersteed has joined #commonlisp
varjag has joined #commonlisp
jonatack has joined #commonlisp
<piethesailor>
Wait not (set-url there is another function that is supposed to do this but I cant find it now. just a second
<Demosthenex>
my apologies, i read anthk_'s mind, please give them the credit since i cheated.
zxcvz has quit [Quit: zxcvz]
dnhester has quit [Ping timeout: 264 seconds]
waleee has joined #commonlisp
<piethesailor>
Well then, thanks for your help anthk_. Demosthenex, you must teach me these psychic powers
mgl has quit [Ping timeout: 268 seconds]
BrokenCog is now known as Gojira
varjag has joined #commonlisp
szkl has joined #commonlisp
danse-nr3 has joined #commonlisp
bendersteed has quit [Quit: bendersteed]
cage has quit [Quit: rcirc on GNU Emacs 29.1]
jmdaemon has joined #commonlisp
Gojira is now known as BrokenCog
Gleefre has quit [Remote host closed the connection]
dnhester has joined #commonlisp
dnhester` has joined #commonlisp
tyson2 has joined #commonlisp
zetef has quit [Remote host closed the connection]
piethesailor has quit [Read error: Connection reset by peer]
piethesailor has joined #commonlisp
rgherdt has quit [Ping timeout: 260 seconds]
chomwitt has quit [Read error: Connection reset by peer]
rogersm has quit [Quit: Leaving...]
mm007emko has joined #commonlisp
amb007 has joined #commonlisp
mm007emko has quit [Quit: Client closed]
rgherdt has joined #commonlisp
igemnace has quit [Quit: WeeChat 4.2.1]
pfdietz has quit [Quit: Client closed]
yitzi has quit [Remote host closed the connection]
istewart has joined #commonlisp
anthk_ has quit [Ping timeout: 264 seconds]
<piethesailor>
anypne use nyxt to do something like (nyxt:find-elements "td" :by :css-selector")?
canbetrustedwith has joined #commonlisp
<BrokenCog>
beach: is the slime-inferior-repl an example of one of those different environments?
canbetrustedwith has left #commonlisp [#commonlisp]
mgl has joined #commonlisp
msavoritias has quit [Remote host closed the connection]
dino__ has joined #commonlisp
dino_tutter has quit [Ping timeout: 255 seconds]
jmdaemon has quit [Ping timeout: 255 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
mgl has quit [Ping timeout: 276 seconds]
yitzi has joined #commonlisp
olvn has quit [Ping timeout: 264 seconds]
X-Scale has quit [Quit: Client closed]
rogersm has joined #commonlisp
kenanb has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.2)]
rogersm has quit [Remote host closed the connection]
rogersm has joined #commonlisp
rogersm has quit [Remote host closed the connection]
rogersm has joined #commonlisp
jmdaemon has joined #commonlisp
rogersm has quit [Remote host closed the connection]
attila_lendvai_ has joined #commonlisp
ymir has quit [Ping timeout: 260 seconds]
danse-nr3 has quit [Read error: Connection reset by peer]
danse-nr3 has joined #commonlisp
mgl has joined #commonlisp
rogersm has joined #commonlisp
danse-nr3 has quit [Remote host closed the connection]
jmdaemon has quit [Ping timeout: 260 seconds]
cosimone has joined #commonlisp
epony has quit [Remote host closed the connection]
jonatack has quit [Ping timeout: 260 seconds]
anthk_ has joined #commonlisp
anthk_ has quit [Client Quit]
dra has joined #commonlisp
dra has quit [Changing host]
dra has joined #commonlisp
<Kingsy>
I have a question if someone is around, is it possible to in defsystem to include all of the files in a directory rather than having to specify them each with :file? maybe a :file "somedir/**" ?
rogersm has quit [Remote host closed the connection]
rogersm has joined #commonlisp
decweb has quit [Remote host closed the connection]
<yitzi>
That sounds like a security risk waiting to happen.
wacki has quit [Read error: Connection reset by peer]
ymir has joined #commonlisp
wacki has joined #commonlisp
<Kingsy>
yitzi: haha you are probably right.
cosimone has quit [Remote host closed the connection]
rogersm has quit [Ping timeout: 276 seconds]
<bike>
i don't think there is any option for this. you have to explicitly list all the components.
<Shinmera>
Kingsy: there is not and for good reason. Lisp files, unlike most batch languages, quickly develop dependencies between each other that ASDF can't figure out on its own
<Shinmera>
so it can't usefully figure out how to automatically order the files
wacki has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
yitzi has quit [Remote host closed the connection]
olvn has quit [Remote host closed the connection]
<younder>
OK, it develops dependencies, but why can't it determine what they are?
X-Scale has joined #commonlisp
cosimone has quit [Read error: Connection reset by peer]
<bike>
common lisp does not make dependencies easy to find through static analysis, and in any case that would be kind of out of scope for asdf.
attila_lendvai_ has quit [Ping timeout: 264 seconds]
<aeth>
Kingsy: the alternate way to organize systems in ASDF is package-inferred-sytem where you create one package per file. It is not directory-aware, though, so the hack to make it directory-aware is to create a your-project/foo.lisp for every your-project/foo/ directory and have it use-reexport with uiop:define-package or similar.
<ixelp>
The package-inferred-system extension (ASDF Manual)
<aeth>
but it is not automatic, and not everything should be use-reexported from a directory
<aeth>
It does figure out dependencies between files very well, though. At the expense of each file being its own package instead of having one package.lisp per project or per subdirectory.
<aeth>
It works because you're explicit about dependencies in the packages. You have to do e.g. import-from in the defpackage if you don't want to use it, even if you're not importing anything (and thus intend to use the package:symbol prefixed style)
<aeth>
s/use it/:USE it/
pfdietz has quit [Quit: Client closed]
<aeth>
so e.g. a foo.lisp could start with (defpackage #:foo (:use #:cl) (:import-from #:alexandria) ...)
amb007 has quit [Read error: Connection reset by peer]
pfdietz has joined #commonlisp
amb007 has joined #commonlisp
anticomputer_ has quit [Ping timeout: 255 seconds]
anticomputer has joined #commonlisp
pve has quit [Quit: leaving]
amb007 has quit [Ping timeout: 268 seconds]
mgl has joined #commonlisp
rgherdt has quit [Quit: Leaving]
shka has quit [Ping timeout: 268 seconds]
X-Scale has quit [Quit: Client closed]
ymir has quit [Ping timeout: 252 seconds]
Odin-LAP has joined #commonlisp
<kagevf>
Kingsy: try something like this to speed things up: (format t "~{(:file ~A)~^~%~}" (mapcar #'file-namestring (directory "*.lisp")))
<kagevf>
then delete-rectangle the ".lisp"s
mgl has quit [Ping timeout: 264 seconds]
<NotThatRPG>
ASDF: Someone had once written an ASDF-groveler, but I think it passed into abandonware.
* NotThatRPG
admits he has never fully grokked how to define a package-inferred system....
amb007 has joined #commonlisp
<NotThatRPG>
I think many implementations provide source-file tracking, so that at least in theory it might be possible to do some of this groveling, except that I don't believe there's any implementation independent source file API.
dino__ has quit [Ping timeout: 256 seconds]
<NotThatRPG>
Kind of a cool project idea, though -- if you could find a distinguished set of graph nodes for exported functions and perhaps other starting points, you could probably crawl backwards to build a graph along "who-calls" links. If it wasn't for that whole "I need to work on things for which I get paid" thing, that would be fun...
ymir has joined #commonlisp
<NotThatRPG>
the "who-calls" links would have to cover macros, and I don't know how one would track dynamic variable references.
<NotThatRPG>
Also one would need to know what entities are *outside* the bounds of the system and provided by its dependencies.
Pixel_Outlaw has quit [Quit: Leaving]
NotThatRPG is now known as NotThatRPG_away
traidare has quit [Ping timeout: 256 seconds]
tyson2 has quit [Remote host closed the connection]