skapata has quit [Remote host closed the connection]
earenndil has joined #lisp
casual_friday_ has joined #lisp
casual_friday has quit [Ping timeout: 276 seconds]
moon-child has quit [Ping timeout: 276 seconds]
earenndil is now known as moon-child
karlosz has quit [Ping timeout: 276 seconds]
purpleLizard has quit [Quit: purpleLizard]
charles` has joined #lisp
Stanley00 has joined #lisp
karlosz has joined #lisp
gitgoood has quit [Read error: Connection reset by peer]
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
purpleLizard has joined #lisp
karlosz has quit [Ping timeout: 276 seconds]
Stanley00 has quit [Remote host closed the connection]
Stanley00 has joined #lisp
hiroaki_ has quit [Ping timeout: 272 seconds]
z3t0 has quit [Ping timeout: 272 seconds]
semz has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
niac has joined #lisp
z3t0 has joined #lisp
varjag has quit [Ping timeout: 265 seconds]
purpleLizard has quit [Quit: purpleLizard]
casual_friday_ has quit [Quit: %bye%]
semz has joined #lisp
Gromboli has joined #lisp
casual_friday has joined #lisp
Stanley00 has quit [Remote host closed the connection]
Stanley00 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
Colleen has quit [Ping timeout: 256 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 264 seconds]
Lord_of_Life_ is now known as Lord_of_Life
swflint has quit [Ping timeout: 260 seconds]
gum has quit [Ping timeout: 265 seconds]
v3ga has joined #lisp
purpleLizard has joined #lisp
swflint has joined #lisp
purpleLizard has left #lisp [#lisp]
gum has joined #lisp
rumbler31 has joined #lisp
Stanley00 has quit []
mr-iznogud has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
asarch has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
jeosol has joined #lisp
slyrus has joined #lisp
madage has quit [Ping timeout: 268 seconds]
mr-iznogud has quit [Remote host closed the connection]
madage has joined #lisp
contrapunctus has joined #lisp
mr-iznogud has joined #lisp
asdflkj has quit [Ping timeout: 276 seconds]
Nilby has joined #lisp
Sheilong has quit []
epony has joined #lisp
slyrus has quit [Read error: Connection timed out]
slyrus has joined #lisp
Alfr is now known as Guest58907
Alfr has joined #lisp
madage has quit [Remote host closed the connection]
madage has joined #lisp
Guest58907 has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has quit [Ping timeout: 268 seconds]
beach` is now known as beach
<beach>
Good morning everyone!
Aurora_v_kosmose has joined #lisp
<fiddlerwoaroof>
morning, beach
charles` has quit [Ping timeout: 260 seconds]
slyrus has quit [Ping timeout: 246 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
slyrus has joined #lisp
slyrus has quit [Ping timeout: 276 seconds]
wxie has quit [Ping timeout: 245 seconds]
wxie has joined #lisp
slyrus has joined #lisp
slyrus has quit [Ping timeout: 276 seconds]
mr-iznogud has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 245 seconds]
Bike has quit [Quit: Lost terminal]
asarch has quit [Quit: Leaving]
narimiran has joined #lisp
actuallybatman has joined #lisp
actuallybatman has quit [Ping timeout: 245 seconds]
<susam>
Good morning, beach!
<susam>
Good morning, everyone!
orivej has joined #lisp
slyrus__ has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
CrazyEddy has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
kam1 has quit [Ping timeout: 260 seconds]
contrapunctus has joined #lisp
rumbler31 has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
frost-lab has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
slyrus__ has quit [Ping timeout: 245 seconds]
sauvin has joined #lisp
<White_Flame>
jeosol: tried PMing you back, but it doesn't seem to be sending?
zap_ has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
frost-lab has quit [Ping timeout: 265 seconds]
contrapunctus has joined #lisp
zap_ has joined #lisp
zap_ has quit [Changing host]
frost-lab has joined #lisp
slyrus has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
slyrus has quit [Ping timeout: 245 seconds]
hjudt has joined #lisp
hjudt has quit [Remote host closed the connection]
shka_ has joined #lisp
aartaka has joined #lisp
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 240 seconds]
flazh has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 264 seconds]
landakram has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
karlosz has quit [Quit: karlosz]
quazimodo has quit [Ping timeout: 264 seconds]
surabax has joined #lisp
White_Flame has quit [Ping timeout: 256 seconds]
pve has joined #lisp
kam1 has joined #lisp
ecraven has quit [Ping timeout: 272 seconds]
kam1 has quit [Quit: Quit]
jonatack_ has quit [Ping timeout: 260 seconds]
random-nick has joined #lisp
<engblom>
Someone here recommended me to use clog for a project but I do not remember anymore who it was
gioyik has quit [Quit: WeeChat 3.0]
ecraven has joined #lisp
<moon-child>
possible dbotton, the clog dev?
<engblom>
Yes, dbotton, it was!
<engblom>
Thank you!
Cymew has joined #lisp
olferino has joined #lisp
olferino has quit [Excess Flood]
White_Flame has joined #lisp
olferino has joined #lisp
olferino has quit [Excess Flood]
<engblom>
What is the difference between (:use :cl ..... ) and (:use #:cl ....)?
<flip214>
engblom: in the first case, you might create a CL symbol in the keyword package (which most likely will already be there); in the second, a symbol in no package is used.
<engblom>
Thanks
rgherdt has joined #lisp
<loke[m]>
flip214: Who was it that always used symbols from the CL namespace for his local variables in order to not pollute the namespace?
<loke[m]>
He was on here some time ago, and was adamant that it was important to save memory or something.
<beach>
I had a student once who used single-character variable names everywhere so that his program would run faster.
<splittist>
Fortran is fast. QED.
<beach>
This is a perfect example of a situation where lack of understanding of what a compiler does can have a negative impact on the maintainability of the code.
<splittist>
I sometimes wish quickref wouldn't title its pages "The [package] Reference Manual" and include the test "This is the [package] Reference Manual" - it can make finding the author-written reference manual (in the rare case there is one) more difficult.
<lukego>
beach: It's easy to laugh, but then I wonder if we are all doing more sophisticated versions of that same mistake all day every day anyway :) compilers and CPUs being so complex that our mental models are never really adequate
<lukego>
maybe it's one of those 80/20 situations though.
<beach>
Many students avoided defining variables in nested blocks inside loops in C, because then "they had to be created each time in the loop".
<loke[m]>
beach: and now people use Python and all of that is true again.
<moon-child>
or they try to reuse variables for disparate purposes because otherwise 'the compiler has to use extra stack space'
<beach>
lukego: My advice was always "If you don't know how the compiler works, then don't make any assumptions"
<loke[m]>
Python is so slow and has no optimiser, so I wouldn't be surprised if declaring a variable in a loop really does have an impact on performance.
<beach>
Heh!
<beach>
Another argument against that language. It's a disaster.
<beach>
moon-child: Yes, that's another good one.
<lukego>
I'm watching people say "lol dynamic typing sucks" on twitter and biting my tongue to make comments that maybe the language they are looking at e.g. Python just isn't putting it to good use :)
<loke[m]>
In my original reference, if I remember correctly the guy was arguing that the core large after dumping was needlessly large if it had interned local variables.
<lukego>
Xach: that's actually really encouraging that there are all these different Lisp universes with totally different cultures e.g. the people who have been using Franz/Allegro env for decades. I occasionally have ideas that seem a bit "outside the mainstream" - bad - but maybe it's really just outside my bubble - potentially good and healthy
landakram has quit [Ping timeout: 240 seconds]
<loke[m]>
@luk
<loke[m]>
lukego: I know nothing about Allegro. How is it different?
<loke[m]>
In any case, they sure know how to prevent people from knowing anything about it. They don't have a free version, do they?
<beach>
loke[m]: It has a nice system for breakpoints, as I describe in my paper on debugging.
<flip214>
loke[m]: no idea.
<lukego>
loke[m]: I don't know, I've never tried living in that bubble, but I'm sure that a day of Lisp hacking for me looks much different than a day of Lisp hacking for (say) Duane Rettig.
<flip214>
beach: single-character variables _were_ faster - on BASIC on the C64 ;)
Grue`` has joined #lisp
jmercouris_ has joined #lisp
rme_ has joined #lisp
Balooga_ has joined #lisp
buoy49_ has joined #lisp
mgxm_ has joined #lisp
griffinbyatt_ has joined #lisp
billstclair_ has joined #lisp
dnm_ has joined #lisp
mgsk__ has joined #lisp
<lukego>
loke[m]: and they don't prevent people in their target market from knowing anything about it, only people like us who wouldn't buy it anyway and would just take up their time complaining about ELI etc :)
mjl_ has joined #lisp
bytesighs_ has joined #lisp
astronavt has joined #lisp
drmeister_ has joined #lisp
stylewarning_ has joined #lisp
CEnnis91_ has joined #lisp
<beach>
flip214: So this is a perfect example of prior knowledge is a disadvantage when attempting to study computer science and/or software development.
<loke[m]>
flip214: To be fair, C64 BASIC only supports 1 or 2 character for variable names :-) So you can choose between slow and slightly slower.
<beach>
Wow!
<loke[m]>
beach: wow! What happened? :-)
beaky_ has joined #lisp
<beach>
Reacting to C64 facts.
<loke[m]>
beach: Ah yes. :-)
<flip214>
beach: _incomplete_ prior knowledge - not knowing _why_ it was slower, and not knowing the difference between an interpreter and a compiler
plisp1 has joined #lisp
<beach>
Yeah.
kim_ has joined #lisp
phoe_ has joined #lisp
shrysr_ has joined #lisp
<flip214>
loke[m]: LDA #34 <<< was soon what I was using instead of BASIC. SYS 64738
antoszka_ has joined #lisp
thonkpod_ has joined #lisp
felideon_ has joined #lisp
olferino has joined #lisp
olferino has quit [Max SendQ exceeded]
swflint has quit [Ping timeout: 264 seconds]
<lukego>
In a large LuaJIT codebase we've had significant performance regressions due to renaming variables in the program. The compiler implements some variables as hashtable entries, the variables are defined incrementally as they are encountered in the running code, the collisions between names causes the hashtable to grow, the JIT emits code that only works well when the hashtable sizes are stable...
xristos_ has joined #lisp
krjt has joined #lisp
<lukego>
took me like a year to write a profiler good enough to sort out the many various messes of those kind
swflint has joined #lisp
<beach>
Incredible.
MadestMadness_ has joined #lisp
varjag has joined #lisp
Necktwi has joined #lisp
CEnnis91 has quit [*.net *.split]
FennecCode has quit [*.net *.split]
phoe has quit [*.net *.split]
mgxm has quit [*.net *.split]
drmeister has quit [*.net *.split]
antoszka has quit [*.net *.split]
Grue` has quit [*.net *.split]
astronavt___ has quit [*.net *.split]
rme has quit [*.net *.split]
thonkpod has quit [*.net *.split]
dale has quit [*.net *.split]
mjl has quit [*.net *.split]
mgsk has quit [*.net *.split]
plisp has quit [*.net *.split]
dnm has quit [*.net *.split]
buoy49 has quit [*.net *.split]
billstclair has quit [*.net *.split]
jmercouris has quit [*.net *.split]
stylewarning has quit [*.net *.split]
bytesighs has quit [*.net *.split]
griffinbyatt has quit [*.net *.split]
Balooga has quit [*.net *.split]
beaky has quit [*.net *.split]
krjst has quit [*.net *.split]
shrysr has quit [*.net *.split]
xristos has quit [*.net *.split]
kim\ has quit [*.net *.split]
felideon has quit [*.net *.split]
mgxm_ is now known as mgxm
felideon_ is now known as felideon
rme_ is now known as rme
mjl_ is now known as mjl
CEnnis91_ is now known as CEnnis91
buoy49_ is now known as buoy49
jmercouris_ is now known as jmercouris
drmeister_ is now known as drmeister
bytesighs_ is now known as bytesighs
dnm_ is now known as dnm
griffinbyatt_ is now known as griffinbyatt
Balooga_ is now known as Balooga
billstclair_ is now known as billstclair
mgsk__ is now known as mgsk
stylewarning_ is now known as stylewarning
dale has joined #lisp
<lukego>
Yeah. The big problem with LuaJIT is that even after you've read all the sources and understand the compiler well enough to use effectively, you can't really explain how it works to other people while keeping a straight face.
retropikzel has joined #lisp
swflint has quit [Ping timeout: 246 seconds]
notzmv has quit [Ping timeout: 264 seconds]
swflint has joined #lisp
* lukego
begins the gradual descent into madness by modelling each pin of each IC in an electronics CAD package as its own CLOS class
<beach>
lukego: The term "CLOS class" is meaningless. All classes are part of CLOS. And every Common Lisp object is an instance of some class.
<beach>
lukego: Most of the time when people use that term, what they seem to mean is "standard class", i.e., the stuff you get most of the time when you use DEFCLASS.
<lukego>
Sure. But '(:GND VCC RST) is a lot different than (defclass GND (pin) ()) (defclass VCC (pin) ()) (defclass RST (pin)))
<beach>
I don't dispute that.
<lukego>
Seems like there's a bunch of information that you need to "hang" somewhere e.g. a certain pin should be connected to ground, another should have 3.3V power input, another should never be connected to anything else, etc. Major design choice seems to be how you organize all that information. I'm trying putting it directly onto the pin objects and making each one an arbitrarily complex "snowflow" with its own class and mthds
<lukego>
snowflake
<beach>
If you create a good protocol, you can alter the implementation as you please at some later point in time.
<lukego>
Tricky business in that I'm reading the datasheets for integrated circuits, and I need to capture all the important details ideally in a single pass, but I don't actually know what format makes sense until I've covered quite a few of them. Maybe I should just be using pseudocode notes but I feel like I've been overdoing that a bit lately.
wxie has quit [Ping timeout: 260 seconds]
* beach
notices the upcoming ELS deadline and decides to work on his call-site paper today.
<lukego>
I'd thought the simplest thing would be to just use symbols and then have generic functions that specialize with EQL but I figure classes are handy for capturing things like mixins and documentation strings
Colleen has joined #lisp
beaky_ is now known as beaky
<moon-child>
lukego: it's not about mixins and documentation strings--you can have those either way--it's just row vs column approach to the expression problem
<lukego>
you guys are no fun :)
<moon-child>
;)
<moon-child>
sorry
ljavorsk has joined #lisp
hendursa1 has joined #lisp
<lukego>
Maybe I'm being too chatty, I'll try to read the room better :)
<moon-child>
nah it's cool
<moon-child>
not like anything else is happening
hendursaga has quit [Ping timeout: 268 seconds]
<lukego>
It's an interesting problem that unfolds. The first pins are easy, like "This pin has to be connected to ground", "this pin should not be connected", "this pin should have a wide copper trace." but now it gets interesting with "this pin should be connected to that other pin with a 1kΩ resistor in between" and so now I need a way for a pin on one part to "imply" a whole other part and a pair of connections
anticrisis has quit [Read error: Connection reset by peer]
<flip214>
lukego: in the past, I've often started with keywords; went to lists; and then structure or classes as the amount of data to store became too unwieldy in a list.
<lukego>
and in a traditional CAD package you might leave this informal for the designer to worry about, or make it a design rule that is checked, but it would be neat to just do it automatically "defmacro style"
<flip214>
nowadays I'm more likely to start with an empty class
nicktick has quit [Ping timeout: 260 seconds]
<lukego>
I think the fact that I'm using CLIM in this application makes me also lean towards using classes. Since then the types I'm defining also have a meaning in that universe e.g. to create presentation methods and so on. I noticed this with Smalltalk - whole classes might feel like overkill but they are darned handy places to hang extension methods for things like graphical inspectors.
<pve>
lukego: what are you building?
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
heisig has joined #lisp
akoana has joined #lisp
akoana has quit [Client Quit]
notzmv has joined #lisp
<lukego>
pve: CAD package for "algorithmic design" of PCBs. Like a KiCad clone but instead of torturously routing the traces by clicking the mouse, you torturously route the traces by tweaking the heuristics
<pve>
lukego: nice!
<loke[m]>
flip214: In a way it was a good thing that C64 BASIC implementation was so dumb. It forced people to learn assembler.
<flip214>
loke[m]: no, it didn't. There was also Pascal, for example.
<loke[m]>
flip214: But Pascal wasn't used much. In fact I have never heard of anyone using Pascal on C64 (that doesn't mean noone did, jsut that this is my experience)
<loke[m]>
There was also a COBOL for C64, did you know that? ;_)
phoe_ is now known as phoe
toorevitimirp has joined #lisp
<lukego>
I didn't learn assembler on the C=64 and that's a lasting regret. I think I was just a bit young though, learned it on the Amiga instead.
<flip214>
is there a (VALUES* ...) analogue to (LIST* ...)?
<beach>
flip214: (apply #'values ....)
<flip214>
beach: ah, yeah, right. VALUES is a normal function, not a special operator...
<beach>
Yep.
<beach>
flip214: "yeah, right" is the only case in English that turns a double positive into a negative. :)
<beach>
flip214: As in "I am the greatest Common Lisp programmer in the world" "yeah, right".
<flip214>
beach: sorry. I'm just a lowly non-native-english speaker, so I wouldn't know about all these fine points...
kevingal has joined #lisp
<flip214>
(but you're right - I already knew that, just didn't #'apply the knowledge when answering. Sorry.)
<beach>
No need to be sorry. I know you are a non-native speaker. So I wanted to let you know.
<beach>
Heh.
kevingal_ has joined #lisp
<lukego>
"yeah, nah" is my favorite english-ism, but I think it might only be aus/nz. it means "actually no"
<lukego>
"I'm the greatest common lisp programmer in the world" "yeah, nah, the great Quux."
<jmercouris>
As another native speaker I would like to also point out that depending on how you stretch out the “yeah” in “yeah, right”, it may be a affirmation OR a negation. A long “yeah” typically signifies negation
wxie has joined #lisp
nicktick has joined #lisp
nullx002 has joined #lisp
<lukego>
I am for the moment resisting renaming these pins from short abbreviations like "pg" and "fb" to proper names like "power-good" and "feedback" but I'll do that later if I think it won't be too confusing wrt referencing specifications.
skapata has joined #lisp
wxie has quit [Ping timeout: 276 seconds]
louis771 has quit [Quit: My M1 has gone to sleep. ZZZzzz…]
louis771 has joined #lisp
cosimone has joined #lisp
* edgar-rft
also likes to design chips with "paul graham" and "facebook" pins
VincentVega has joined #lisp
paulj has quit [Remote host closed the connection]
<VincentVega>
Is there a way to get access to a class-allocated slot value without instantiation?
attila_lendvai has quit [Ping timeout: 265 seconds]
pankajsg has quit [Ping timeout: 256 seconds]
jonatack has joined #lisp
<lukego>
I'm veering towards having a separate PACKAGE for each kind of IC now and maybe that is accelerating the descent into madness? but I'd quite like to represent each type of pin as its own class, and ICs tend to have pins with the same names but different properties
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
Aurora_v_kosmose has quit [Remote host closed the connection]
sjl has joined #lisp
<splittist>
The punning of 'package' is attractive
contrapunctus has joined #lisp
<X-Scale>
lukego: are you trying to simulate hardware modules and their interconnections in LISP ?
rgc has joined #lisp
nullx002 has quit [Quit: ERC (IRC client for Emacs 27.1)]
<lukego>
no, I'm trying to do design rule checks (enforce requirements specified informally in the datasheet) and to automate the busywork (e.g. add external resistors/capacitors that are required but not interesting enough to bother a human about)
nullx002 has joined #lisp
<lukego>
also I'm trying to blur the line between "schematic" and "board design." I'll do both at the same time as a single operation. So my "schematic" will include board-related requirements e.g. that certain traces can't have vias, must be short, must be wide, etc.
Aurora_v_kosmose has joined #lisp
schweers has joined #lisp
Carkh has quit [Remote host closed the connection]
Oddity has joined #lisp
<beach>
X-Scale: Are you new here? I don't recognize your nick.
rozenglass has joined #lisp
<X-Scale>
beach: I've been in this channel for around 16 years. I just don't talk much. I mostly lurk :)
<flip214>
lukego: have the _classes_ of pins (vcc, gnd, GPIO) in one package; and an IC has an array of pins, which are instances of these classes.
<beach>
X-Scale: Got it.
<flip214>
you can also model the pins via multiple inheritance - a specific pin could be an anonymous class with parents (GPIO MISO ANALOG-IN PWM), for example.
<lukego>
flip214: That's what I'm thinking. But then each IC is different, and a "GPIO" pin for IC FOO is not the same as for IC BAR, so I'm thinking I'll have separate foo:GPIO and bar:GPIO classes (and factor as much as make sense into common superclasses and mixins)
<lukego>
This might be a bit extreme but it would seem to give maximum flexibility for adding weird and wonderful design rules based on quirks described informally in data sheets
<lukego>
(Of course I can redo all this later, at the moment I'm just thinking aloud as I make a first pass through a set of datasheets, trying to find some notation for writing down details that I want to capture but aren't really sure about how yet)
<flip214>
lukego: perhaps it would be more sane to fix quirks by having some additional superclass IC-FOO-QUIRKS-2021/3.2? that would also help to reference the special quirk...
orivej has quit [Ping timeout: 245 seconds]
<lukego>
yeah could be so. I guess that this also fits with having a separate class per pin per IC
<lukego>
I am maybe a bit drunk on the apparent cheapness of defining classes, we'll see how the hangover is tomorrow...
<flip214>
lukego: in case of such special quirks, you could simple have a _named_ class for this pin - and override methods on it. for "normal" pins without quirks (are there any?? ;) an anonymous class with inherited behaviour is used.
<lukego>
I've not even heard of anonymous classes before...
<beach>
lukego: Well, they can be anonymous in the sense that FIND-CLASS won't find them.
<flip214>
but (at least from a debugging POV) it might be much easier to just name them after the IC and pin.
<flip214>
do you also plan to have multiple revisions of ICs, with slightly different behaviour?
ewd has joined #lisp
orivej has joined #lisp
<lukego>
I want to say "no" but...
aggin has joined #lisp
nullx002 has quit [Quit: ERC (IRC client for Emacs 27.1)]
<flip214>
so you might need a way to clone an IC revision but with a few pins being a different class...
aggin has quit [Client Quit]
<lukego>
Just now I have a (pins IC) method that returns the pins i.e. does a make-instance on the appropriate pin classes and assigns them IDs (numbers) to match the datasheet. So I guess for revisions and errata I could make subclasses of the IC and override the PINS method to apply the tweaks
nullx002 has joined #lisp
nullx002 has quit [Client Quit]
Oladon has joined #lisp
nullx002 has joined #lisp
schweers has quit [Ping timeout: 258 seconds]
ggole has joined #lisp
slyrus has joined #lisp
orivej has quit [Ping timeout: 276 seconds]
slyrus has quit [Client Quit]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
hiroaki_ has joined #lisp
peasynt has joined #lisp
yonkunas has joined #lisp
aggin has joined #lisp
aggin has quit [Client Quit]
schweers has joined #lisp
pankajsg has joined #lisp
Lycurgus has joined #lisp
attila_lendvai has quit [Ping timeout: 256 seconds]
curtosis has joined #lisp
kevingal has quit [Remote host closed the connection]
kevingal_ has quit [Remote host closed the connection]
<jmercouris>
how to find functions in my code that are not called anywhere?
<jmercouris>
I can "who-calls" and see if there are any entries, of course this is not bulletproof
<jmercouris>
there are still convoluted ways to funcall
<jmercouris>
I'm not looking for a perfect suggestion, just a way to find candidate orphaned defuns
<Lycurgus>
grep and all you get is the def?
<Nilby>
I believe CCL reports on unused functions.
<jmercouris>
that would work... I guess
<jmercouris>
but you would need a list of all defuns to pass to grep
<jmercouris>
I will see what CCL has to offer
ldb has quit [Remote host closed the connection]
<Bike>
it's hard to gauge what's actually unused, and what is just used in code you haven't loaded yet, or is intended for repl use
flazh has joined #lisp
<Bike>
i suppose if you wanted to mechanize it you could make a list of non exported symbols from your package, see what's fbound, and grep for those
arpunk has quit [Remote host closed the connection]
<Nilby>
Yes, it's probably better to say CCL warns about unused functions in some limited circumstances.
<jmercouris>
well yeah
<jmercouris>
that's what I'm saying
<jmercouris>
there's all sorts of way a particular codepath isn't hit
<jmercouris>
I just want to know if that symbol doesn't appear elsewhere in the codebase
<jmercouris>
that's more or less all you /could/ know
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
cosimone has joined #lisp
charles` has joined #lisp
luni has quit [Quit: Connection closed]
charles` has quit [Ping timeout: 245 seconds]
schweers has quit [Remote host closed the connection]
cosimone has quit [Quit: cosimone]
contrapunctus has quit [Ping timeout: 240 seconds]
pranavats has quit [Ping timeout: 272 seconds]
ukari has quit [Remote host closed the connection]
<jmercouris>
how can I get "salmon"? given just the #<FUNCTION SALMON>
<jmercouris>
I understand it is a bit of a nonsense question
<jmercouris>
I guess functions don't need to have names
<jmercouris>
...
<_death>
you can try function-lambda-expression
<jmercouris>
hm...
rwcom60280385034 has joined #lisp
<jmercouris>
I guess that may work
nullx002 has quit [Quit: ERC (IRC client for Emacs 27.1)]
<jackdaniel>
swank::function-name would be an answer, but as you have pointed out, it is just a conveniance hack (i.e returns a name with which the function was defined)
<jackdaniel>
because the function may have many (or no) names
<jackdaniel>
s/no/none/
<jmercouris>
yeah, this is a generalized problem with our API
<jmercouris>
the user can specify a list of actions to be performed on a list of objects
<jmercouris>
this list of actions can be a function, a lambda, a symbol (which should point to a function)
Lycurgus has quit [Quit: Exeunt]
<jmercouris>
the problem is, how to represent anonymous functions to the end user
rwcom60280385034 has quit [Client Quit]
<jmercouris>
we can't just write "ANONYMOUS FUNCTION"
<jmercouris>
they should know what it intends to do
<heisig>
jmercouris: Sounds like a case for funcallable standard objects with additional metadata.
<jmercouris>
how could we declare a lambda with additional data?
<jmercouris>
we would need to wrap it in some form like (action "name" (lambda () ...)) ?
<jackdaniel>
just subclass funcallable and slap there a slot name
<jmercouris>
hm
<jackdaniel>
oh, what heisig said
<jackdaniel>
time to grab a coffee to not duplicate other answers :)
<_death>
or (defstruct callable function ringtone)
<jmercouris>
yes
<jmercouris>
we need a class
<heisig>
Of course this means you'll have to wrap closures somehow. But this wrapping is kind of the point, because you want to add additional information for your users.
Bourne has quit [Ping timeout: 245 seconds]
<jmercouris>
Yes
Cymew has quit [Ping timeout: 260 seconds]
<heisig>
You could also have a custom DEFUN-like macro that does the wrapping for top-level definition. Bonus points if that macro supports (interactive ...) clauses :)
vhost- has quit [Quit: WeeChat 2.8]
<jmercouris>
we already have a defun-like macro
<Nilby>
I do something like that where a user action can just be a form, which can be internally cached as function.
<jmercouris>
you know what, maybe I am overthinking
<jmercouris>
or whatever that type of alternating list is called
<jmercouris>
I can't ever remember plist vs alist
<jmercouris>
or maybe a two dimensional list
ggole has quit [Quit: Leaving]
<jmercouris>
decisions decisions decisions...
aindilis has quit [Ping timeout: 260 seconds]
pankajsg has quit [Ping timeout: 260 seconds]
nullx002 has joined #lisp
contrapunctus has joined #lisp
vhost- has joined #lisp
vhost- has joined #lisp
<jackdaniel>
you should focus on the actual problem. over and over again you ask, how you can get a salmon - you should either make a contract with a local store or invest in a rod ,)
<jmercouris>
hm, a good idea, I should buy a boat
rwcom60280385034 has joined #lisp
Demosthe1ex is now known as Demosthenex
nullx002 has quit [Client Quit]
ewd has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
nullx002 has joined #lisp
flazh has quit [Ping timeout: 260 seconds]
nullx002 has quit [Client Quit]
slyrus has joined #lisp
heisig has quit [Quit: Leaving]
nullx002 has joined #lisp
nullx002 has quit [Client Quit]
xantoz has quit [Ping timeout: 256 seconds]
gitgood has quit [Read error: Connection reset by peer]
Josh_2 has joined #lisp
anticrisis has joined #lisp
paulj has joined #lisp
ljavorsk has joined #lisp
<Josh_2>
Hi
amb007 has quit [Read error: Connection reset by peer]
<Josh_2>
Is there a library that utilizes metaclasses to save to and load from a file? the format should be a human readable format so that someone could edit it
amb007 has joined #lisp
ljavorsk has quit [Ping timeout: 260 seconds]
<Josh_2>
I'm not fussed about the format, but currently I just save my object as a list, but I assume someone will have written a library that does this for me
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<_death>
it sounds like cl-prevalence, but may also want to check out clobber
nullx002 has joined #lisp
nullx002 has quit [Client Quit]
<Josh_2>
does that let me just serialize my class object and save it to a file? I don't need transaction records etc
<Josh_2>
ooh maybe cl-store
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Josh_2>
ah rip thats not really human readable
kevingal has joined #lisp
<jasom>
I don't know of anything that checks all the boxes, but I think cl-store lets you customize the format, so you might be able to make it human-readable
<markasoftware>
Josh 2, how important is the customization of the serialization format
<Josh_2>
it just has to be human readable so that users can edit it, plus I need to be able to stop the serialization of some slots
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Josh_2>
honestly if I can't find something I can probably just make something myself
<Josh_2>
What I have now works just fine, It's just a pain if I want to add any new slots
<markasoftware>
Are you still trying for a lispy format or nah
amb007 has quit [Read error: Connection reset by peer]
<Josh_2>
doesn't matter, just needs to be readable
<markasoftware>
With parens
<Josh_2>
with human eyes :P
amb007 has joined #lisp
<Josh_2>
and obviously needs to be read back into the lisp image
sauvin has quit [Remote host closed the connection]
attila_lendvai has quit [Ping timeout: 240 seconds]
<markasoftware>
this may or may not be sufficient for you, i wrote it a while back https://paste2.org/6peXV2De
hiroaki_ has quit [Ping timeout: 272 seconds]
<markasoftware>
it converts an object and slots into a cons-only structure, which you can then just (print)
<Josh_2>
I'll give it a run
<Josh_2>
Thanks
<markasoftware>
by default, it works on slots that have initargs set
<markasoftware>
but if you specialize consify-initargs you could remove slots you don't want
<Josh_2>
Okay epic
<jasom>
Josh_2: cl-marshal looks like it meets your requirements
<markasoftware>
the main functions are (consify) and (unconsify)
<jasom>
https://github.com/wlbr/cl-marshal never used it, but it hits all of the points including letting you specify which slots of an object should be serialized
contrapunctus has quit [Ping timeout: 264 seconds]
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
hiroaki_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
contrapunctus has joined #lisp
orivej has joined #lisp
jeosol has quit [Quit: Ping timeout (120 seconds)]
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
<Josh_2>
Well Marshal doesn't seem to be working for me
<jasom>
though a few tests I just ran on cl-marshal show some weaknesses; it only marshals to a list, so it is up to you to turn thie list into a string (presumably with *print-readably*. It also does not generate references for non-aggregate types, so you would need *print-circle* to correctly handle gensyms (though that still would only guarantee equality within the serialization, which is the best you
Oladon has quit [Quit: Leaving.]
<jasom>
can practically do with a serialization format)
<Josh_2>
I can marshal my primary object but I cannot unmarshal it
<Josh_2>
I get an 'index-too-large-error
<Josh_2>
I think I will just utilize some of what markasoftware provided to make it easier to extend my own
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
asdflkj has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<cage_>
Josh_2, what are you trying to unmarshal?
amb007 has joined #lisp
<Josh_2>
the result of evaluating (ms:marshal <my object>)
<cage_>
i have not touched the library in years, if you can show some code to reproduce the issue i can try to see what is wrong
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<cage_>
i am quite busy but i will try to address the problem when (and, sadly if) possible :)
<cage_>
ah and thank you for wrapping olm library! :)
<Josh_2>
:)
<Josh_2>
I still need to put it to good use in my Matrix bot
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
narimiran has quit [Ping timeout: 245 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
rogersm has joined #lisp
<cage_>
Josh_2, sorry to bother but may i ask to provide the code to initialize the class, sorry for the lazyness
<Josh_2>
uh
<Josh_2>
It's initialized from a config file
<Josh_2>
Let me see if I can knock up an example for you
<markasoftware>
for what it's worth i just discovered that my (consify) will not work on improper lists, i will need to think about this
<cage_>
Josh_2, thak you
<cage_>
* thank
Lycurgus has joined #lisp
<cage_>
that form with (LIST 2 NIL NIL NIL) look strange to me
<cage_>
this is the form that the library can not handle properly
<Josh_2>
Oh right I see
actuallybatman has joined #lisp
<Josh_2>
Thats probably because I specialized my class and put '(communities ..) as one of the slots, while not telling cl-marshal how to marshal a community
<cage_>
the library should signals something meanigful
rogersm has quit []
galex-713 has quit [Ping timeout: 260 seconds]
contrapunctus has quit [Ping timeout: 245 seconds]
<cage_>
jasom, sorry but my knowlege of the library is a bit rusty, i think the library can already serialze/deserialze symbols so thre is some problem that your code adrress that i can not see at this moment
<cage_>
can you tell me abot the issue with symbols?
<cage_>
*about
<jasom>
cage_: right now it serializes symbols as symbols and does not generate e.g. references for gensyms
jeosol has joined #lisp
<cage_>
ahh
<cage_>
i see
<jasom>
so two problems: 1) the SEXP->(string|bytes) must be package aware 2) the SEXP->(string|bytes) must be *print-circle* aware.
<cage_>
i think the library know about the package
<jasom>
cage_: it does for objects, not symbols
<jasom>
(ms:marshall 'foo) -> FOO
<cage_>
right!
<cage_>
i think i am starting to undertand, thanks
<cage_>
*understand
<jasom>
(let ((*package* <any package>) (*print-circle* t) (*print-readably* t)) (print)) (and similar dynamic bindings for (read)) will work; just about any other way of stringifying the sexp is likely to have subtle bugs
flazh has joined #lisp
<cage_>
your code to serialize symbols seems reasonably to me (but take into account i am a bit tired :-)) would you file an pull request?
<cage_>
also i really would appreciate a test :)
<jasom>
cage_: sure maybe this weekend though if you want a test too :)
<cage_>
no problem!
<cage_>
take your time
<cage_>
honestly my knowelege of CL never would allow me the problem you brougth to my attention here
galex-713 has joined #lisp
<cage_>
so thank you!
<cage_>
interesting discussion, as usual, in this channel!
luni has quit [Quit: Connection closed]
actuallybatman has quit [Ping timeout: 276 seconds]
akoana has joined #lisp
<cage_>
time to go, bye!!
cage_ has quit [Quit: Leaving]
sxmx has quit [Quit: WeeChat 3.0.1]
ljavorsk has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 26.1]
Lycurgus has quit [Quit: Exeunt]
sxmx has joined #lisp
charles` has joined #lisp
retropikzel has quit [Ping timeout: 260 seconds]
Fade has quit [Remote host closed the connection]
aartaka_d has quit [Read error: Connection reset by peer]
Fade has joined #lisp
hineios has joined #lisp
ljavorsk has quit [Ping timeout: 245 seconds]
shka_ has quit [Ping timeout: 264 seconds]
karlosz has quit [Ping timeout: 260 seconds]
pankajsg has joined #lisp
karlosz has joined #lisp
lieven has quit [Quit: WeeChat 1.6]
pve has quit [Quit: leaving]
lieven has joined #lisp
mindCrime has joined #lisp
surabax has quit [Quit: Leaving]
nicktick has quit [Ping timeout: 276 seconds]
zupss has quit []
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
ech has joined #lisp
quazimodo has joined #lisp
pranavats has quit [Ping timeout: 276 seconds]
jonatack has quit [Ping timeout: 256 seconds]
<White_Flame>
hmm, cl+ssl doesn't quickload because of a non-exported symbol from usocket. This can't just be me, right?
<White_Flame>
broke in my old code when I cleared cache, as well as after the latest update-all-dists
<White_Flame>
usocket::host-to-hostname, to be specific
charles` has quit [Ping timeout: 276 seconds]
<White_Flame>
^ Xach
minion has quit [Remote host closed the connection]
minion has joined #lisp
specbot has quit [Disconnected by services]
specbot has joined #lisp
madnificent_ has joined #lisp
jonatack has joined #lisp
gurmble has joined #lisp
<_death>
usocket exports this symbol since late 2018