<malice>
I was wondering whether you could do something like (flet <definition of function X> (setf (<value of local function> X) <other function>)), but you can't.
<malice>
Am I right?
<malice>
(there's no practical solution or hacking in mind here)
kozy has joined #lisp
Trasformatore has quit [Ping timeout: 256 seconds]
<malice>
Riiiiight. I was thinking of setf though. Someone asked about defun = setf fdefinition, and I was thinking of ways of rebinding local functions
<malice>
though your example is nice, pjb :)
Karl_Dscc has quit [Remote host closed the connection]
wheelsucker has quit [Read error: Connection reset by peer]
<aeth>
Imo, if you don't actually need the features flet offers, consider defining separate functions just for debugging and clarity. e.g. (defun %foo (x y z) "something-internal") or even (declaim (inline %foo)) (defun %foo (x y z) "something-internal")
<aeth>
Pretty much every time I've started with a flet, I wound up later refactoring it out of the function for clarity.
<aeth>
%foo is usually local enough. If people use it, it's their fault, the % is warning them not to use it.
<malice>
not exporting might also be a hint.
wheelsucker has joined #lisp
pedh has joined #lisp
Devon has quit [Ping timeout: 260 seconds]
pedh has quit [Ping timeout: 265 seconds]
nyef`` has joined #lisp
schoppenhauer has quit [Ping timeout: 265 seconds]
pseudonymous has quit [Ping timeout: 265 seconds]
nyef` has quit [Ping timeout: 248 seconds]
wxie has quit [Quit: Bye.]
Zhivago has joined #lisp
Jesin has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
jameser has joined #lisp
pseudonymous has joined #lisp
Devon has joined #lisp
varjag has quit [Ping timeout: 240 seconds]
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jameser has joined #lisp
<Xach>
aeth: that rarely happens to me, but i often convert them to labels
<Xach>
i mainly stop with flet when there's only one local function. but even then sometimes it gets recursive and needs a labels.
pseudonymous has quit [Remote host closed the connection]
pseudonymous has joined #lisp
dtornabene has joined #lisp
turkja has joined #lisp
impulse has joined #lisp
Devon has quit [Ping timeout: 248 seconds]
bigos_ has joined #lisp
pedh has joined #lisp
pseudonymous has quit [Ping timeout: 264 seconds]
jack_rabbit has quit [Ping timeout: 248 seconds]
milanj has joined #lisp
pedh has quit [Ping timeout: 248 seconds]
jameser has quit [Read error: Connection reset by peer]
jameser has joined #lisp
jameser has quit [Client Quit]
resttime has joined #lisp
mejja has joined #lisp
<dmiles>
can someone share with me a test case that is an example where alpha renaming is required to make something work?
<dmiles>
often times i notice macros will use a gentemp to avoid problems when used recursively.. i've assumed that was to avoid some renaming that work automatically happen
Fawfil has joined #lisp
<dmiles>
to avoid some renaming that may otherwise not happen automatically
jameser has quit [Read error: Connection reset by peer]
safe has joined #lisp
<resttime>
Any resource/tutorial out there for working with the bytes/bits for numbers like C? I dunno a good way of getting two bytes high/low and combining them to make a signed 16bit integer (short) and vice versa.
jameser has joined #lisp
jameser has quit [Read error: Connection reset by peer]
<resttime>
I can think of an explicit solution jsut by reading bits but I'm wondering if there's something more 'built-in'
jameser has joined #lisp
jameser has quit [Read error: Connection reset by peer]
raphaelss has joined #lisp
<fiddlerwoaroof>
resttime: pcl has a couple chapters on making a binary format parser
<Zhivago>
See LDB?
jameser has joined #lisp
<fiddlerwoaroof>
also, this ^
jameser has quit [Read error: Connection reset by peer]
jameser has joined #lisp
jameser has quit [Read error: Connection reset by peer]
<resttime>
That works, I can (ldb (byte 15 0) (logior (ash #xFF 8) #x01)) then read the MSB to for the sign
lclark` has joined #lisp
knobo has quit [Ping timeout: 248 seconds]
joshandersen has joined #lisp
<resttime>
Is there anything like (coerce combined-bytes '(signed-integer 16)) that exists?
joshandersen is now known as tom45
tom45 has quit [Client Quit]
lclark has quit [Ping timeout: 272 seconds]
smurfrobot has quit [Remote host closed the connection]
pmetzger has quit [Remote host closed the connection]
pmetzger has joined #lisp
pmetzger has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 248 seconds]
<fiddlerwoaroof>
resttime: you can do something like (setf (ldb ...) ...)
tom45 has joined #lisp
drichards has quit []
tom45 has quit [Client Quit]
Kundry_Wag has joined #lisp
smurfrobot has joined #lisp
<resttime>
fiddlerwoaroof: To replace the ASH and LOGIOR?
lisp_guest has quit [Ping timeout: 256 seconds]
<fiddlerwoaroof>
I think so: if the destination is all zeroes, you can just use #'(setf ldb) to set the appropriate bytes
<fiddlerwoaroof>
s/bytes/bits/
<fiddlerwoaroof>
But, I don't really do all that much bit-twiddling in CL
<resttime>
Neither do I :)
Kundry_Wag has quit [Ping timeout: 272 seconds]
<fiddlerwoaroof>
What are you trying to do?
smurfrobot has quit [Ping timeout: 264 seconds]
<resttime>
Reading in a short integer from a serial device that sends a low byte and high byte
<resttime>
I basically get a byte array so I need to combine the bytes
pmetzger has joined #lisp
<Zhivago>
You could use a bit vector/
<Zhivago>
But it's probably simplest to assemble an integer from the bytes arithmetically and use ldb.
ebzzry has joined #lisp
bigos_ has quit [Remote host closed the connection]
pmetzger has quit [Ping timeout: 265 seconds]
damke_ has joined #lisp
<resttime>
Sweet, found a function DPB: (dpb (aref byte-vector 0) (byte 8 8) (aref byte-vector 1))
red-dot has quit [Remote host closed the connection]
red-dot has joined #lisp
<resttime>
Then multiply the result (ldb (byte 15 0) combined-bytes) based on the MSB (ldb (byte 1 15) combined-bytes)
pmetzger has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<resttime>
So far this seems to be the best solution, I still wonder though if there's something like (coerce combined-bytes '(signed-integer 16))
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
milanj has quit [Quit: This computer has gone to sleep]
varjag has joined #lisp
varjag has quit [Ping timeout: 248 seconds]
EvW has quit [Ping timeout: 265 seconds]
Sam__ has joined #lisp
Sam__ has quit [Client Quit]
binary_ has joined #lisp
<binary_>
Hey all, this might be a stupid question but does anyone know why learnlispthehardway.org is down?
<nyef``>
resttime: Not easily-and-portably. I typically end up with something like (defun sign-extend (value width) (if (logbitp (1- width) value) (logior (ash -1 width) value) value)).
<nyef``>
resttime: If you're working with machine-native types, you might be able to do something clever with an FFI system.
mejja has quit [Quit: mejja]
<fiddlerwoaroof>
binary_: I've never heard of it before, but it looks like you can find it on github
<fiddlerwoaroof>
Also, practical common lisp is a good way to learn lisp
<binary_>
I've been using the github, it's just that the hyperlinks are ill-adapted for markdown (read-- it would take a hell of a regex to make them work). I'll check out Practical Common Lisp, thank you!
<fiddlerwoaroof>
minion: tell binary_ about practical common lisp
<minion>
binary_: look at practical common lisp: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
wigust has joined #lisp
malice has quit [Remote host closed the connection]
wxie has joined #lisp
<beach>
Good morning everyone!
<fiddlerwoaroof>
morning, beach
pmetzger has quit [Ping timeout: 240 seconds]
zaquest has quit [Quit: Leaving]
smurfrobot has joined #lisp
binary_ has quit [Quit: Page closed]
smurfrobot has quit [Ping timeout: 260 seconds]
Fare has joined #lisp
<Fare>
Looks like cl-json is also ripe for forking. Sigh.
smurfrobot has joined #lisp
zaquest has joined #lisp
<fiddlerwoaroof>
Fare: yason is pretty good too
<aeth>
There is a correct, lossless default mapping, i.e. going cl <-> json losslessly. Afaik, none of the major libraries do that by default.
<aeth>
This channel was discussing that a couple of days ago
<nyef``>
I've been using st-json. How did that one stack up?
<fiddlerwoaroof>
Generally, I don't think that matters
<aeth>
iirc the correct methodology for losslessness is: null <-> :null; false <-> nil; [] <-> #(); {} <-> (make-hash-table)
<fiddlerwoaroof>
If [] <-> #() you can use nil for null
<aeth>
cl-json's default is particularly bad because it doesn't have a :null so it goes null <-> nil and false -> nil
exit70 has left #lisp [#lisp]
<aeth>
fiddlerwoaroof: In Scheme, yes
<fiddlerwoaroof>
I'd rather booleans turn to keywords
<aeth>
You want to disambiguate between null-as-nil (not very common in CL) and null-as-false (extremely common in CL)
<nyef``>
Hrm. IIRC, st-json uses :false for false and nil for [].
smurfrobot has quit [Ping timeout: 264 seconds]
<aeth>
fiddlerwoaroof: In cl-scheme, yes, I turn #f into :false, but that's because Scheme has lists, so CL's nil is becoming '() so I can use the built-in list data structure
<fiddlerwoaroof>
to mee (emptyp (parse "null")) should be true
<aeth>
But mapping null, as in the nonsense thing that breaks type symbols, into nil is not a good idea imo
<nyef``>
I like :null as null because I can pass that from JSON straight to the database and back if necessary.
<aeth>
s/breaks type symbols/breaks type systems/
<aeth>
"null" is literally just "the thing that breaks type systems" and there is no direct equivalent in CL, where nil, even when used in a sort of nullish way, is false.
impulse has quit [Quit: leaving]
fikka has joined #lisp
<aeth>
The only time CL's nil behave sort of like a null is when working with lists because (listp nil) is true. Otherwise, you're only going to get nil as null if you define it as such, e.g. the type definition (or null simple-vector)
<aeth>
And you're probably going to ruin some optimizations by doing so.
pierpa has quit [Quit: Page closed]
<fiddlerwoaroof>
Anyways, I try not to use null in my json anyways
<fiddlerwoaroof>
Generally [] or {} is more meaningful
pedh has joined #lisp
<aeth>
an alternative way of dealing with {} is tagged plists.
<nyef``>
Ah, the other thing that I find important is to know when there ISN'T a field by a particular name in a {}.
<aeth>
In fact, it would work with [] as well
<aeth>
an empty tagged plist or tagged list would still not be nil because the cdr would be nil and the car would be the tag
<fiddlerwoaroof>
[] -> vectors and {} -> hash tables seems fine to me
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<fiddlerwoaroof>
Especially in the latter case, where you're probably going to be looking things up by keys
fikka has quit [Ping timeout: 265 seconds]
<aeth>
(:json-list 1 2 3) -> [1, 2, 3] and (:json-object :foo 42 :bar 7) -> {"foo" : 42, "bar" : 7} seems decently sensible, especially if by default it's a one-way mapping and the vector/hash-table thing is the default. I don't think that would cause issues.
<aeth>
Well, besides going from symbol to string, but you get that with hash-tables, too. Treating it in a case insensitive way (i.e. upcase to symbol and downcase to string) would usually work unless you're processing arbitrary JSON from the outside world, which could be an overridable flag.
pedh has quit [Ping timeout: 240 seconds]
<aeth>
Because then an empty list is (:json-list) so the JSON knows to turn nil into false
<aeth>
(And JSON knows which one is a plist and which one is a list)
MochaLoca has joined #lisp
LocaMocha has quit [Ping timeout: 265 seconds]
EvW has joined #lisp
pmetzger has joined #lisp
wxie has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 264 seconds]
<Fare>
fiddlerwoaroof, I just meant that cl-json's maintainer seems to have dropped the ball, so forking is required.
<Fare>
A lot of CL projects seem to be unmaintained.
<fiddlerwoaroof>
Yeah
<fiddlerwoaroof>
Or, minimally maintained
<Fare>
When simple github PRs that unbreak the build go unanswered after many months, it's time to fork.
<Fare>
but hey, what do I know.
pedh has joined #lisp
<Fare>
If I were still actively developing CL code, I'd join sharplispers and fork a lot of stuff...
<jackdaniel>
Fare: why didn't you fork a lot of stuff when you did actively develop CL code then?
<jackdaniel>
good morning o/
<beach>
Hello jackdaniel.
<pjb>
(loop do … until … do … while … do … until … do … while … do …)
smurfrobot has joined #lisp
<Fare>
jackdaniel, I did fork, take over or helped maintain a few: ASDF, POIU, ASDF-DEPENDENCY-GROVEL, CL-CONTAINERS, CL-PROTOBUFS, LAMBDA-READER -- in addition to those I started.
<jackdaniel>
another thing is that if they work fine and changes to buildsystem make them break, then is it really problem with support or maybe rather ecosystem stability?
<Fare>
And I sent my share of PRs to other projects.
<Fare>
what if they didn't work that fine, but the bugs they had weren't as visible when the build system itself had its own bugs that are now fixed?
<Fare>
All code bitrots, and needs to be maintained.
<Fare>
When I fixed F2CL to work with ASDF 3.3, the code I had to replace was not just bad design that violates the ASDF interfaces, it also had a lot of bugs in corner cases.
<Fare>
the old code that happened to work in the conditions that the original author tried them isn't sacred, and its bugs don't deserve to live forever.
smurfrobot has quit [Ping timeout: 272 seconds]
<aeth>
Does asdf have any support for files that compile to .lisp files?
<Fare>
jackdaniel, another reason I didn't fork as much back in the days was because there were all these other hackers who hadn't quit yet, like I'm doing.
<jackdaniel>
I agree that software has bugs. I disagree with implicit equalizing bugs with buildsystem problems. but what do I know? I need to go and fix bugs in software I maintain before sunset
<Fare>
aeth, yes, see f2cl for instance, or cffi-grovel
<pjb>
As long as you have specifications to sort the bugs from the features…
<Fare>
jackdaniel, going into another project's undocumented internals and expecting it to keep working forever... it's a bug.
<Fare>
pjb: there is a specification, indeed --- the documentation.
<Fare>
... and even the specification sometimes evolves, to account for previously unforeseen circumstances.
<nyef``>
The traditional stability guarantee for anything using internals of another project, documented or not, is "if it breaks you get to keep both pieces."
<Fare>
ASDF has its share of poking at other project internals, BTW, so will need maintenance when these internals change.
<Fare>
aeth: yes, and you define new operations to work with it.
<Fare>
you'll need a new operation that compile-op and load-source-op depend on, that creates the .lisp file.
zaquest has quit [Read error: Connection reset by peer]
<Fare>
I saw some horrors that made sense when written for unmaintained 2006 ASDF 1, but don't make sense at all for 2017 ASDF 3.3. Is it a bug to fix them? I say no.
<Fare>
I mean, when ASDF 3 breaks them, 2006 kluges are bugs that need to be fixed, not enshrined with more kluges on the ASDF side.
LiamH has quit [Quit: Leaving.]
zaquest has joined #lisp
nsrahmad has quit [Ping timeout: 265 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
orivej has quit [Ping timeout: 265 seconds]
nsrahmad has joined #lisp
milanj has joined #lisp
nsrahmad has quit [Ping timeout: 265 seconds]
holycow has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
red-dot has joined #lisp
dddddd has quit [Remote host closed the connection]
nullman has quit [Ping timeout: 255 seconds]
nullman has joined #lisp
<aeth>
Wow, the roswell update process is messy. I basically had to delete both the installed directory and .roswell to get it to run without either segfaulting the C part or erroring in the CL part (which, interestingly, both did and didn't drop me into the debugger depending on how and when it errored in the process)
smurfrobot has joined #lisp
<aeth>
but I guess roswell is the way to go to quickly test a library on as many implementations as possible with "ros use foo; ros emacs &"
damke has joined #lisp
smurfrobot has quit [Ping timeout: 265 seconds]
milanj has quit [Quit: This computer has gone to sleep]
damke_ has quit [Ping timeout: 264 seconds]
turkja has quit [Ping timeout: 265 seconds]
turkja has joined #lisp
smurfrobot has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
smurfrobot has quit [Ping timeout: 265 seconds]
SAL9000_ is now known as SAL9000
ARW12 has joined #lisp
ARW12 has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
fourier` has joined #lisp
fourier` is now known as fourier
fourier has quit [Changing host]
fourier has joined #lisp
Amplituhedron has joined #lisp
akkad has joined #lisp
nalkri has joined #lisp
circ-user-tdc4F has joined #lisp
zaquest has quit [Ping timeout: 272 seconds]
ericmathison has joined #lisp
zaquest has joined #lisp
pedh has joined #lisp
dliot has joined #lisp
pseudonymous has joined #lisp
mishoo_ has joined #lisp
shka has joined #lisp
pedh has quit [Ping timeout: 248 seconds]
impulse has joined #lisp
smurfrobot has joined #lisp
oleo has quit [Quit: Leaving]
smurfrobot has quit [Ping timeout: 264 seconds]
lisp_guest has joined #lisp
pseudonymous has quit [Remote host closed the connection]
pseudonymous has joined #lisp
oleo has joined #lisp
pedh has joined #lisp
Mon_Ouie has joined #lisp
pedh has quit [Ping timeout: 272 seconds]
damke has quit [Ping timeout: 264 seconds]
damke has joined #lisp
quazimodo has joined #lisp
safe has quit [Read error: Connection reset by peer]
Murii has joined #lisp
nirved has joined #lisp
dliot has quit [Quit: dliot]
pseudonymous has quit [Remote host closed the connection]
pseudonymous has joined #lisp
dliot has joined #lisp
dliot has quit [Client Quit]
yara414 has joined #lisp
yara414 has quit [Remote host closed the connection]
royalo426 has joined #lisp
royalo426 has quit [Remote host closed the connection]
wysokil92 has joined #lisp
heurist` has joined #lisp
heurist has quit [Ping timeout: 240 seconds]
wysokil92 has quit [Remote host closed the connection]
DeadTrickster has quit [Read error: Connection reset by peer]
DeadTrickster has joined #lisp
Karl_Dscc has joined #lisp
pedh has joined #lisp
akkad has quit [Quit: Emacs must have died]
pedh has quit [Ping timeout: 272 seconds]
drack999 has joined #lisp
drack999 has quit [Remote host closed the connection]
dliot has joined #lisp
bigos_ has joined #lisp
DeadTrickster has quit [Read error: Connection reset by peer]
DeadTrickster has joined #lisp
DeadTrickster has quit [Client Quit]
varjag has joined #lisp
steve-v525 has joined #lisp
steve-v525 has quit [Remote host closed the connection]
lisp_guest has left #lisp ["WeeChat 1.9.1"]
giacin393 has joined #lisp
giacin393 has quit [Remote host closed the connection]
varjag has quit [Ping timeout: 248 seconds]
pseudonymous has quit [Ping timeout: 248 seconds]
Murii has quit [Quit: WeeChat 1.4]
Murii has joined #lisp
bail417 has joined #lisp
bail417 has quit [Remote host closed the connection]
smurfrobot has joined #lisp
random-nick has joined #lisp
damse185 has joined #lisp
damse185 has quit [Remote host closed the connection]
wooden has quit [Quit: leaving]
<fourier>
anyone uses series package ?
smurfrobot has quit [Ping timeout: 240 seconds]
<fourier>
i did some simple tests against hand-written loops and purely functional approach to the same problems (like sum of squares of a list of numbers) and was surprised what the code generated by series is as performant as hand-written loops and at least twice more performant than pure functional approach with reduce/map
Murii has quit [Quit: WeeChat 1.4]
pseudonymous has joined #lisp
GaM142 has joined #lisp
GaM142 has quit [Remote host closed the connection]
astri219 has joined #lisp
astri219 has quit [Remote host closed the connection]
<Fare>
I have friends who use iterate
<Fare>
I suppose series can do a lot of simplifications and optimizations
<Fare>
whereas naive map/reduce sees its arguments as opaque and must do a lot of "administration" at runtime
frob has joined #lisp
frob has left #lisp [#lisp]
<fourier>
series basically generates loops with (go) out of composition of expressions. cool what it is generate as performant code as hand-written loop while still using functional approach.
frob1 has joined #lisp
frob1 has left #lisp [#lisp]
<fourier>
yep functional approach lead to creating intermediate lists after applying remove-if/subseq etc, which definitely hits the performance
dddddd has joined #lisp
quazimodo has quit [Ping timeout: 248 seconds]
jmercouris has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
<jmercouris>
If you like my project, please consider leaving a star, I'll be working on the GTK port in earnst for the next release, so any help in this domain would be greatly appreciated!
<jmercouris>
Thank you for your time
knobo1 has joined #lisp
smurfrobot has joined #lisp
milanj has joined #lisp
knobo has quit [Ping timeout: 240 seconds]
papatya253 has joined #lisp
papatya253 has quit [Remote host closed the connection]
pedh has joined #lisp
<jmercouris>
I also would be extremely interested if any users have any feedback, please feel free to contact me via any medium
<jmercouris>
unless it's something like smoke signals, in which case I cannot guarantee reception
<beach>
I see some code duplication between history-add and history-typed-add. You might want to create a common abstraction for those.
Murii has joined #lisp
<beach>
In fact, (sqlite:connect (truename (probe-file ...))) is repeated several times.
<jmercouris>
beach: Yeah, there's some macro that allows you to use the database, but I couldn't figure it out how to work
<beach>
A lot of duplication, in fact.
<jmercouris>
so you can normally do something like (with database ...) and it'll be like a context thing
<beach>
Just create a function already.
<jmercouris>
Maybe, I would like to figure out the proper way actually, the way the lib wants you to do it
<beach>
(defun bla (name) (sqlite:connect (truename (probe-file name))))
wxie has quit [Remote host closed the connection]
<beach>
Except that you need a better name than BLA.
<jmercouris>
I have to go cook breakfast now, but I'll be back/read anything, thank you for the suggestions thus far
<jmercouris>
It is something I will have to add for release 0.08!
<jmercouris>
Lot of code cleanup
<jmercouris>
beach: One other thing, I wanted to make a (with-new-buffer) macro, but I couldn't think of a good way to do it
zaquest has quit [Ping timeout: 272 seconds]
<beach>
What is match-count?
<jmercouris>
a lot of my functions involve acting on the current buffer, and then there is a derivative acting on anew buffer
<beach>
If it is a special variable, it should have earmuffs.
<jmercouris>
match-count is the amount of times a term appears on a page
smurfrobot has joined #lisp
<jmercouris>
beach: It is in parenscript, so I'm very hesitant to write earmuffs, not sure if they are supported in JS, but I try
<beach>
Yes, I am not reading the code in order to understand what it does. Just doing superficial stuff.
<jmercouris>
beach: Fair enough, that is also still very useful to me, I miss a lot of things as you can see :D
<jmercouris>
I get so used to reading my own code, I don't even realize what is wrong
<Zhivago>
Looks like parenscript claims to support special variables in the documentation.
<beach>
(node-children (active-history-node (mode ...))) is also duplicated many times.
<beach>
CHILDREN is a list that might be empty, right?
knobo1 has quit [Ping timeout: 264 seconds]
<beach>
If so, don't write (WHEN CHILDREN ...) because WHEN suggests that it is a Boolean value. I would write (UNLESS (NULL CHILDREN) ...) instead, as Norvig and Pitman suggest.
<beach>
And you need to work on your LOOP indentation. I suggest you use SLIME-INDENTATION to get it right.
<beach>
Furthermore, you have inconsistent LOOP formatting. Sometimes you have DO at the end of a line, and sometimes at the beginning. It is best to put it at the beginning of the line that starts the clause.
<Zhivago>
Although to be honest, if you want to talk about a list being empty, I'd write (when (empty children) ...) -- null is quite semantically overloaded, too.
FreeBirdLjj has joined #lisp
<fourier>
whats wrong with (when children ..) ? any examples how it could fail
zaquest has joined #lisp
<|3b|>
fourier: same meaning to lisp implementation, but might be interpreted differently by human readers
* |3b|
personally finds (when x ...) easier to parse than (unless (whatever x) ...) though
<fourier>
same
<fourier>
also lisp-critic will suggest changing that (unless (null ..) ..) to (when ..)
<Zhivago>
fourier: You can think of it (when children ...) being an implied (when (true children) ...).
atgreen has joined #lisp
<Zhivago>
Personally I think if you're happy with overloading null, then you might as well be happy with overloading it in the opposite direction.
<fourier>
its a common pattern in c as well, so nothing bad here (I guess)
<Zhivago>
But the half-arsed position of doing one but not the other is just silly.
<|3b|>
yeah, i think UNLESS EMPTY is better than UNLESS NULL for me, but still worse than just WHEN
<Zhivago>
In C, I'd certainly prefer to see if (empty_list(list)) than if (list).
* |3b|
probably wouldn't tell people to change any of them though, since that's just 'for me' :)
pedh has joined #lisp
<beach>
fourier: It has nothing to do with semantics and everything to do with the intention as communicated to the reader of the code.
<|3b|>
empty_list(list) in C would suggest a non-null object with no contents to me
<Zhivago>
It might -- but more importantly it abstracts the representation away.
<Zhivago>
And since C has no common list structure this is more important to communicate perhaps than in CL.
<|3b|>
true, if you aren't treating it as aa pointer in general it doesn't matter
pedh has quit [Ping timeout: 264 seconds]
<beach>
Zhivago: Right, it would be better to write (UNLESS (ENDP ...) ...)
FreeBirdLjj has quit [Remote host closed the connection]
damke_ has joined #lisp
<borodust>
hello #lisp
<beach>
Hello borodust.
<borodust>
indentation in emacs CL (via slime) buffer is often breaks for me if there are docstrings present
<fourier>
i got a feeling what it mostly relevant for string variables,, which could either be null or "". I use alexandria:emptyp for this case then (unless (emptyp arg)..)
damke has quit [Ping timeout: 263 seconds]
<beach>
borodust: Are you using SLIME-INDENTATION?
<borodust>
did anyone else experience that?
<borodust>
as in emacs package?
FreeBirdLjj has joined #lisp
<beach>
borodust: As in a SLIME contribution, yes.
<borodust>
hmm, i'm using 'slime-fancy that includes a bunch of stuff (mb indent one too)
pmetzger has quit [Ping timeout: 264 seconds]
<beach>
I don't think so.
<borodust>
i see, lemme try
<beach>
Also for docstrings, I use #.(format nil ...) so that I can use ~@ at the end of lines and indent the next line without affecting the docstring.
<borodust>
i'm actually thinking moving all docstrings into separate files
<beach>
Yes, I do that, but I still use #.(format nil ...).
varjag has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<borodust>
hmm, i added slime-indentation to slime-setup list but that didn't help :/
<Shinmera>
borodust: Parens at the beginning of lines within strings or comment blocks screw with SLIME
<Shinmera>
Use \( if you have that.
<borodust>
:sigh
<borodust>
thanks Shinmera
<borodust>
that was it
<Shinmera>
Hoorah for regex based matching
<beach>
Wow.
* beach
instantly wants to work on the incremental Common Lisp parser.
<Shinmera>
:)
<jmercouris>
Ok, so I'll always put do on the line with the clause, that's a good rule to have
<jmercouris>
In terms of the when, unless not, I always prefer not using double negatives, so that one I will have to consider for some more time
pjb has quit [Read error: Connection reset by peer]
<beach>
I am amazed that this issue always gets debated when I bring it up.
<jmercouris>
In terms of indentation, I don't like always what slime is doing for me, especially in parenscript, it has some strange behavior sometimes
<beach>
I take it most people in #lisp are not used to collaborative programming. I guess that's kind of normal in some way.
cpape has quit [Read error: Connection reset by peer]
cpape has joined #lisp
raynold has quit [Read error: Connection reset by peer]
nydel has joined #lisp
bigos_ has quit [Remote host closed the connection]
fikka has joined #lisp
jameser has joined #lisp
jameser has quit [Client Quit]
<jmercouris>
I am very used to collaborative programming, that's why I'm such a huge fan of standards
<jmercouris>
it's just that this rule is directly in conflict with another rule in Python
<beach>
That's hilarious.
<beach>
Rules are per-language.
<jmercouris>
In python one should only care about the truthiness, and I think that's a good way of doing things
nirved has quit [Ping timeout: 272 seconds]
<jmercouris>
why should I care if it is a list or not? only that its value is false
<shka>
jmercouris: i don't get ya
<beach>
jmercouris: Notice how you say "I always prefer", "I don't like", "I think that's a good way".
nirved has joined #lisp
raynold has joined #lisp
<shka>
beach: hello, btw
<beach>
Hello shka.
<jmercouris>
beach: What are you trying to say?
<shka>
have a nice sunday!
<beach>
jmercouris: That you claim to be in favor of standards, but then you have several objections that indicate that your personal preference if more important.
<jmercouris>
beach: I think you're right I should reconsider my objections, thank you for pointing out this inconsistency
<beach>
jmercouris: Look, I don't care how you write your code. I gave you advice that corresponds to what two great Common Lisp gurus have written. If you don't want to follow it, then that's fine with me.
fikka has quit [Ping timeout: 264 seconds]
<jmercouris>
beach: I understand you have no stake in it, which is what makes your opinion objective and useful, you don't have to remind me of that
<beach>
OK, good.
fourier has quit [Ping timeout: 272 seconds]
<jmercouris>
I am always ready to admit when I am wrong, which is unfortunately too frequently :D
<shka>
nah
<shka>
being wrong is fine
<shka>
being stubborn is not
<jmercouris>
shka: being wrong is fine, being stubborn is the worst, and being correct is the best ;)
<shka>
sometimes there is no "correct"
* |3b|
thinks being stubborn isn't too bad when you are right, but since you tend to think you are right when you are wrong, any blanket rating of stubbornness isn't much use :)
pmetzger has joined #lisp
pedh has joined #lisp
pjb has joined #lisp
<Zhivago>
I think it's simply honest to say, "I prefer X", rather than "X is better".
<shka>
yes, but who cares about that? ;-)
<jmercouris>
Zhivago: that it is, I was not lying about my position :D, but it is true that I should be more open to reconsidering some of my opinions if they conflict with some of the best lisp devs
<jmercouris>
maybe in the end I will not agree, but I should give them a more thorough consideratio
stara has joined #lisp
groovy2shoes has quit [Quit: moritura te saluto]
dmiles is now known as dmiles[m]
pedh has quit [Ping timeout: 272 seconds]
Tota|Ev613 has joined #lisp
<Tota|Ev613>
▄▄▄▄▄▄▄▄▄▄▄▄▄ HAPPY NIGGER DAY!! PLEASE SAY HI TO ALL THE DUMB NIGGERS IN #FREENODE...quicktalkeh676te.onion/6697dsyhmwnj: jack_rabbit Fare holycow ericmathison heurist` oleo Zhivago MochaLoca wheelsucker nullman Mon_Ouie davsebamse shka kozy mishoo_ josemanuel d4ryus1 _Trasformatore_ wigust nirved FreeBirdLjj smurfrobot cpape pmetzger damke_ raphaelss nydel nalkri atgree
Tota|Ev613 has quit [Killed (Sigyn (Spam is off topic on freenode.))]
<shka>
uhm
<shka>
guy has a problem
<jackdaniel>
bot creator?
<shka>
yes
<shka>
why he would like to do anything like this
<jackdaniel>
there must be systematic problem causing this, becuase number of people loosely called trolls raises and I'm not only talking about the internet
<jackdaniel>
something not quite right with the society directions I'd say, if it were #lispcafe ;)
<jackdaniel>
but since it #lisp, I'll say: PAIP is an amazing book
<jackdaniel>
it's*
<shka>
it certainly is
<jmercouris>
I think it's a spam bot, probably trying to agitate you into clicking the URL
<jackdaniel>
shka: oh, you're reading PAIP too?
<jmercouris>
so it names as many nicks as possible
<shka>
jmercouris: i finished it already
<shka>
i bought book last year
<shka>
so i had a massive head start
<shka>
jmercouris: sorry, tabfail
<jmercouris>
shka: It's okay, I figured as much :)
<jackdaniel>
good for you
<shka>
PAIP was my first contact with prolog
<shka>
i am awed by it
<shka>
there is so much around it that is interesting
<shka>
term indexing, WAM and so on
<shka>
knowledge representation
marvin3 has joined #lisp
xenon- has joined #lisp
<xenon->
hi
<xenon->
I think there's a function that does this, but I can't recall its name.
<jackdaniel>
does what?
<xenon->
(lambda (x) (if (< x 0) -1 1))
<jackdaniel>
signum
<xenon->
thanks!
<jackdaniel>
sure
<dmiles[m]>
shka: not sure if you heard of CYC?
turkja has quit [Ping timeout: 240 seconds]
<xenon->
I guess I might as well ask if there's a function that does this? :). (lambda (x) (* (signum x) (floor (+ (abs x) 0.5))))
<dmiles[m]>
shka: have you heard of or studied CYC?
<jmercouris>
This isn't exactly a lisp question, but I've been thinking about how to monetize nEXT so that I can work on it full time, and one idea that I had was this: opt-in crypto mining, something like, "If you want to support nEXT development, please install/configure miner plugin" and I could have a really well made plugin that can be set to use only up to 5% cpu, only during specific times, etc, so that if a user wants to help, they can
<jmercouris>
any thoughts on this?
<Shinmera>
That's not gonna get you any money is my thought
<jmercouris>
Shinmera: It really depends on which coin you are mining and how you are trading things
shenghi has quit [Remote host closed the connection]
<jmercouris>
You are right, if I only have 50 users, it may not make any money, but if I have 1000 users, maybe I can make like 500 a month or something
LiamH has joined #lisp
shenghi has joined #lisp
<Zhivago>
Well, you're probably just in time to watch bitcoin crash and burn.
<jackdaniel>
Zhivago: I share the same suspition, but I had it 3 years ago or so too
<jmercouris>
Zhivago: :D, there will be a crash as there has been many times before, but I think there is a future in cryptocurrency
<Zhivago>
Sure, just not a completely stupid one.
<Zhivago>
I'd consider tying into the mobile app infrastructure.
<jmercouris>
Yes, bitcoin has a lot of problems, but that is not the essence of my question, I didn't even mention bitcoin
<jmercouris>
Zhivago: Can you please elaborate what you mean?
<Zhivago>
If you had an app which you could buy for $1 which unlocked some features, then that might be below the threshold of annoyance for users.
<fourier>
best way to monetize nEXT is to use it as your cv to get a better job I'm afraid
pedh has joined #lisp
<Zhivago>
I'm unlikely to pay money to someone via ebay, but I'm at the point where I don't find it unreasonable to unlock something in an app for $1.
<Zhivago>
er, paypal, rather.
<jmercouris>
fourier: I will at some point, I am trying to get a new contract job soon, but I would like to try to make it work at some point
<Zhivago>
Simply because the infrastructure makes it easy to do so rather than an enormous pain in the arse.
<pjb>
Eventually, 1 BTC = 800,000+ USD; we won't trade in BTC but in Satoshi ≈ 1¢.
<borodust>
Xach: howz your experience with trivial-gamekit so far? was the documentation of any help? any hard edges?
<Zhivago>
If bitcoin gets to that stage, we'll be using all of the planet's power production on bitcoin computation.
<Zhivago>
Which is why bigcoin really can't.
<pjb>
Not really, and you're forgetting to compare the power consumption of the current banking system.
<jmercouris>
Zhivago: I've always felt that crypto was so ecologically irresponsible, we are just wasting cycles on bullshit
<Shinmera>
Can we not turn this into #bitcoin
<fourier>
then think about casual users and not about lispers. what advantages your browser has to someone to donate/pay for it, considering chrome, firefox, opera, etc are widely available
<drdo>
pjb: Damn, I missed your "eventually" when glancing and almost believed you with the crazy growth that has been going on lately
<pjb>
Everything is #bitcoin today :-)
<Zhivago>
jermcouris: Well, it's not the crypto that's the fundamental cost here.
<jmercouris>
fourier: Do you have some ideas?
<pjb>
jmercouris: it's expensive to maintain a distributed network of workers. Really, it's not that simple.
<fourier>
no, im happy with current state of browsers with their plugins Im afraid again..
<jmercouris>
I have been thinking so far about this: the ability to send pages with marked up to non nEXT users, backups for bookmarks, history etc, synchronization of data across devices
<jmercouris>
pjb: Computationally expensive? or ?
<fourier>
this all already exist in other browsers
<jmercouris>
fourier: no, one cannot send a document with markup to another individual
<pjb>
jmercouris: no, it's a lot of work.
pedh has quit [Ping timeout: 248 seconds]
<pjb>
programming, admin, etc.
<jmercouris>
maybe I should just sell corporate licenses, and hope that people use it in their place of business :D
<fourier>
have you searched for plugins for that for firefox? :)
<jmercouris>
pjb: Ah, yes, definitely
<jmercouris>
fourier: I'm good
<Zhivago>
jermcouris: You could always add loot boxes.
<jmercouris>
Zhivago: lmao
<jmercouris>
Another idea that I had recently was an "opt-in" amazon affiliates, like some simple config you can add so that you are using my amazon affiliates code to support nEXT
<fourier>
should be something distinctive feature, the killer feature
<jmercouris>
fourier: what would be your killer feature? what have you always wanted to do?
<jmercouris>
maybe there is a way to give users a sense of pride and accomplishment?
<Zhivago>
I saw an app like that.
<fourier>
maybe smart tabs/window management. like group all stackoverflow tabs to one window etc
<fourier>
typical problem browser users have is too many open tabs
<Zhivago>
You paid $1000 and could show people an icon of a diamond, which gave users a sense of pride and accomplishment in being rich enough to waste $1000 on an icon of a diamond.
circ-user-tdc4F has quit [Ping timeout: 272 seconds]
<jmercouris>
fourier: That would be very simple to implement given my current architecture, anyone could just make a plugin that does it
<fourier>
do it if its simple, dont wait for users
<jmercouris>
Yes, but I can't charge them for something they could make themselves in 10 minutes lol
<pjb>
Also, nowadays people don't use desktop browsers anymore; they browse the web on tablets and handheld computers, where energy consumption is closely watched. If you app drains the battery, it'll get deleted soon.
<Shinmera>
You'd be surprised
<fourier>
and provide this plugin as an example
<Zhivago>
Something they could make themselves in 10 minutes if they were you?
<jmercouris>
pjb: It is a desktop only browser, it is made for actual work, not for "browsing"
<pjb>
ie. you cannot count on a large base of computing node, if you target desktop.
<jmercouris>
Zhivago: Yes, I guess if they were me :D, perhaps a different person would spend a couple days
<pjb>
better spend your time on better browsing features, than on managing mining.
<pjb>
If you want to earn money mining then buy mining hardware.
<Zhivago>
And a couple of days work is a reasonably large opportunity cost.
<fourier>
as for us lisp nerds it would be cool if you build it in as a plugin to say Climacs and Lispworks, to popup and show clhs in it real quick and easy :)
<fourier>
beach: how is Climacs now? is it usable for CL code now, can it replace emacs+slime for simple usage patterns?
<jmercouris>
pjb: I will investigate more
raynold has quit [Quit: Connection closed for inactivity]
<jmercouris>
One last final thought I had to sound off you guys, I was considering making "paid plugins" that do things that would mostly only be interesting to someone using nEXT in a corporate environment, things like single sign on integration, VPN integration
<pjb>
This sounds a better idea.
<pjb>
If you can find such a customer.
<pjb>
Ie. you're not selling a browser, you're selling a solution to a specific corporate problem.
<jmercouris>
I was imagining such a customer would be someone who works at a startup that uses my browser
<fourier>
yep that is nice
Folkol has joined #lisp
<jmercouris>
and they want to use it for all of their stuff at work, so they need some support for a few things
ebzzry has quit [Ping timeout: 256 seconds]
<fourier>
jmercouris: can I install it from quicklisp and launch off my CL? so I can use my repl to operate/controll it
terpri has quit [Ping timeout: 248 seconds]
<jmercouris>
fourier: Yes, but it isn't in the quicklisp repositories
<jmercouris>
fourier: please note, MacOS only at the moment, I'm learning/working on the GTK port
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<fourier>
jmercouris: on my attempt to load it this way I got an error: Error: Can't create directory "/Applications/Clozure CL.app/Contents/Resources/ccl/mac-ui/".
<fourier>
While executing: ENSURE-DIRECTORIES-EXIST
<pjb>
fourier: /Applications is usually owned by root.
<pjb>
Make a local copy of the application ~/Applications/ and proceed from there.
<pjb>
alternatively, patch it to use a different target directory for compilation and generation of temporary files.
<pjb>
cf. #ccl
<fourier>
yep, its rather ccl or some dependency problem.
<pjb>
I would say it's a ccl bug: it generates stuff in its src or installation directory.
pseudonymous has quit [Remote host closed the connection]
pseudonymous has joined #lisp
<fourier>
no I was thinking mostly of using browser as a part of lisp image, i.e. to present html documentation in the CL-based app.
<jmercouris>
fourier: then you will probably want to install CCL not with the mac app, but with the "manual" installation
<Shinmera>
Loading a huge system just to show some docs doesn't seem like a great course of action
<jmercouris>
Shinmera: Huge system? I pull in VERY few dependencies, and all the libraries for Cocoa/Webkit exist natively on OSX
<jmercouris>
My binary with a complete CL image, etc, is 15MB
<jmercouris>
Adding nEXT to any existing CCL image will add probably AT MOST a few KB to the image, though I haven't tested it to be sure
<Shinmera>
Huge in terms of functionality being pulled in.
dieggsy has joined #lisp
Intensity has quit [Ping timeout: 246 seconds]
<jmercouris>
Ah, in that case you are correct!
<Zhivago>
jmercouris: Looking at nEXT, it's not really clear to me what real-world problem it solves.
<Zhivago>
(which makes it hard to see how to market it)
stara has joined #lisp
dliot has joined #lisp
<jmercouris>
Zhivago: The problem next solves is that it gives power users a way to tailor and extend their browser to their workflow to be more efficient in ways that are currently (and probably never will be) possible in casual browsers meant for general-purpose browsing
turkja has quit [Ping timeout: 264 seconds]
<Zhivago>
So, this is a competitor to javascript?
<jmercouris>
Zhivago: As an example, let's say your job requires you to fill out a web-form with the date all the time, and there are maybe 30 of these web-forms linked from a master page. You could write a plugin that opens 30 new tabs with all of the forms, enters the current date, and then maybe some other functions for populating the forms with data
<jmercouris>
Zhivago: Yes and no, Javascript is limited only in that it can change the web-view itself, nEXT allows you to manipulate and change the Chrome in ways that JS does not
fikka has quit [Ping timeout: 260 seconds]
asarch has joined #lisp
<jmercouris>
Zhivago: So you might make a plugin that changes the transparency of unrelated windows, or opens up 10 new frames, or executes some lisp code on your machine, etc
<Zhivago>
Ok, although we can already do that using a programmatic browser -- and those are used a lot of scraping.
<jmercouris>
Zhivago: Maybe you could, but this is just the main difference of nEXT, the other great thing is that this environment has enabled me to develop a lot of very cool extensions very quickly to just make one quicker at browser than in general, the combination of all of these plugins together is what makes it better than something like Chrome
<jmercouris>
Zhivago: Additionally, nEXT is not beholden to some arbitrary plugin ecosystem that can decide "NO MORE API FOR YOU!" as we witnessed in the Firefox Apocalpyse
red-dot has joined #lisp
<Zhivago>
Fair enough. So browser automation, then. I assume that it runs javascript like a proper browser? :)
<jmercouris>
Zhivago: Yes, though I refused to put any JS directly in my codebase, and anything I'm using JS for is written in parenscript macros
<jmercouris>
s/written in parenscript macros/written in macros that generate parenscript from parenscript source
<Zhivago>
I think you need to work on writing this down for your site, since reading it doesn't make it very clear.
milanj has quit [Quit: This computer has gone to sleep]
<jmercouris>
Zhivago: The marketing message is a little confused indeed because I am trying to target too many audiences at once, on one hand, I would be very glad to have the support of the lisp community as they will be the chief innovators/users of the product, and on the other hand, I want to make sure that people who haven't used a productivity-centric browser can understand the advantages it may confer to them
<Zhivago>
I'd consider making distinct messages for each group.
<jmercouris>
Zhivago: If you have better ideas for a marketing message, please send me an email or make a pull request, I did have a very nice user contact me the other day with a message, I need to look it up/ will repost it shortly when I find it
<jmercouris>
Zhivago: Here's the message the guy came up with: nEXT is a keyboard-oriented, extensible web-browser inspired by Emacs and designed for power users. The application has familiar key-bindings, is fully configurable and extensible in Lisp, and has powerful features for productive professionals.
EvW has quit [Ping timeout: 265 seconds]
turkja has joined #lisp
EvW has joined #lisp
<Xach>
borodust: i have had some trouble
<Xach>
borodust: however, i need to work on having proper expectations and understanding of how things work before reporting things as bugs
<beach>
fourier: (first) Climacs works, but it isn't good enough for what I want. So I am working on Second Climacs, which will have a much more sophisticated incremental analyzer of Common Lisp code.
dieggsy has quit [Ping timeout: 255 seconds]
<borodust>
Xach: what was the problem?
Intensity has joined #lisp
<Xach>
borodust: i started a window with a little demo code that draws a square at the mouse cursor. when i close the window and try to re-start it, i end up in the debugger.
<borodust>
Xach: ah, i see, it isn't quite stable in this regard at this moment and there known problems when engine is restarted several times per image (probably due to a resource leak). Does this still happen if you close window with #'gamekti:stop?
<borodust>
Xach: i fixed related problem recently, updating dist should help
* borodust
only hopes he didn't break anything else :/
<Xach>
borodust: i am using the latest
<borodust>
actually, hold on, i didn't publish those yet
<borodust>
yeah
orivej has quit [Remote host closed the connection]
orivej has joined #lisp
<borodust>
Xach: updated dist
atgreen has quit [Remote host closed the connection]
atgreen has joined #lisp
CrazyEddy has quit [Ping timeout: 264 seconds]
atgreen has quit [Client Quit]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
atgreen has joined #lisp
red-dot has joined #lisp
Kevslinger has joined #lisp
orivej has quit [Remote host closed the connection]
orivej has joined #lisp
peterhil has quit [Quit: Must not waste too much time here...]
fikka has joined #lisp
<jmercouris>
Goal: Move element to the beginning of list, What would be the better approach: Make a copy of the list with the element in the first position, Modify list in place with car/cdr, Anything else?
EvW has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 265 seconds]
peterhil has joined #lisp
<pjb>
better for what?
<jmercouris>
That's a good question, I'll give some more specifics, the list is between 0-50 elements, frequently changing in size
<jmercouris>
Which approach would be more readable? more lispy?
<beach>
If the element is already at the beginning, do nothing. Otherwise, find the CONS cell that precedes the one containing the element. Short-circuit the list using (setf cdr). Finally link the unlinked cell to the beginning of the list.
<pjb>
Can it contain duplicates? Is it shared (do you have multiple references to its cells)? Are there multiple threads accessing it in parallel?
<jmercouris>
pjb: There is only one master reference to this list, no one may delete something from this list without using this lists reference
CrazyEddy has joined #lisp
<beach>
Or, if you don't care about the order of the remaining elements, swap the first element with the one you want to move.
<jmercouris>
There are multiple thread accessing it in parallel, but they may only read
<jmercouris>
beach: I care about their order
<jmercouris>
I'm trying to remember the term for this kind of stack/structure
<pjb>
do you want the threads to be able to read at the same time you move the element?
<beach>
jmercouris: priority queue.
<jmercouris>
I think the term is something like spatially recent, it's on the tip of my tongue
fikka has joined #lisp
<jmercouris>
pjb: The threads have reference to the individual elements, I would rather not create/destroy the elements, only change the list itself
<beach>
Maybe not.
<jmercouris>
Let me look through my notes...
pedh has joined #lisp
<pjb>
jmercouris: also, you said that the size changes. How (what thread) do you remove elements?
<pjb>
(from the head, the middle, the tail?)
<jmercouris>
pjb: Only the main thread may add/delete elements
<jmercouris>
They are always pushed onto the list, and deleted with delete
<jmercouris>
so I always do something like this (setf listy (delete delete-this-element listy))
<jmercouris>
and I add only via (push new-element listy)
<pjb>
If you already use delete to delete them, then (setf list (cons element (delete element list))) would be a consistent way to move it to the front.
terpri has joined #lisp
<beach>
jmercouris: You can do that if performance is not a big deal.
<jmercouris>
Well, this operation is not executed more than lets say once a minute, and the list is small
<beach>
No problem then.
<jmercouris>
Ok, I will do this way then
<pjb>
you may want to add :count 1 if you can have multiple occurences.
<jmercouris>
I understand speed is implementation dependent
<pjb>
for delete it'll be O(n).
<jmercouris>
but if the elements within the list are large, does this affect the speed of the creation of the list? I cannot see why it would, but maybe there is something I dont know
AntiSpamMeta has quit [Excess Flood]
<pjb>
No, it does not.
<beach>
No, it won't.
AntiSpamMeta has joined #lisp
dliot has quit [Quit: dliot]
fikka has quit [Ping timeout: 256 seconds]
<pjb>
What may matter is the test you use. By default it's eql which is O(1).
Tobbi has joined #lisp
JohnnyL has joined #lisp
<pjb>
But if you use eg. :test 'string= then it becomes O(m), total O(m*n).
<jmercouris>
Yeah, I have a reference always to the item I want to move, so I can leave it at eql
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
milanj has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
SuperJen has joined #lisp
Tobbi has joined #lisp
Guest96622 has quit [Ping timeout: 264 seconds]
dliot has joined #lisp
jmercouris has quit [Ping timeout: 265 seconds]
Tobbi has quit [Ping timeout: 272 seconds]
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
Jen has joined #lisp
Jen is now known as Guest23
dliot has quit [Quit: dliot]
SuperJen has quit [Ping timeout: 272 seconds]
<fourier>
anyone got to work Lisp syntax highlighting on Github Pages ?
dieggsy has joined #lisp
Tobbi has joined #lisp
JenElizabeth has joined #lisp
Guest23 has quit [Ping timeout: 272 seconds]
<dim>
``` lisp
<dim>
oh, or maybe you mean something else, I use Github Pages but with a local static HTML toolkit: gohugo (used to be home made CL code but I don't care about maintaining that)
<fourier>
```lisp does not really work for me... maybe theme prevents it ? i'm using minima theme.
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jmercouris has joined #lisp
stara has joined #lisp
JenElizabeth has quit [Ping timeout: 256 seconds]
<jmercouris>
1. I have a GUI that has a textbox, 2. I can only prompt the textbox for its value, 3. I recieve all keystroke events in my program 4. I want to make a blocking read/input function similar to on a terminal, 5. do you think I should use a semaphore to do this?
Murii has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 272 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
<shka>
jmercouris: you should not
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<shka>
it makes things complicated
<jmercouris>
shka: Ok
<shka>
use event loop if you must
<jmercouris>
let me provide a full context, then, tell me what you think instead
<jmercouris>
One moment please
<shka>
but don't create more threads then you need (that would be one for GUI and one for internal logic)
red-dot has joined #lisp
Josh_2 has quit [Read error: Connection reset by peer]
<jmercouris>
Tell me if the example doesn't make sense
fikka has joined #lisp
Jen has joined #lisp
<shka>
certainly bad idea
<jmercouris>
So, my current solution is entirely non-blocking because I pass a reference to a function which I call at some point in the future
fikka has quit [Read error: Connection reset by peer]
Jen is now known as Guest51695
<jmercouris>
I think that a blocking input solution is good for a lot of simple little functions
<shka>
i would not do that
<jmercouris>
Otherwise you have to chain your inputs in strange ways
<shka>
yes
<shka>
i would rather focus on make this chaining easier
<jmercouris>
Well, let's consider a very simpel example
<shka>
blocking threads leads to more threads, more threads leads to more locks, more locks lead to problems and performance degradation
<fourier>
should you maintain a stack of ui elements, whoever on top should receiev all events and propagate to the next on stack if they are not consumed?
<shka>
so for GUI apps i rather prefer just two threads
SuperJen has quit [Ping timeout: 256 seconds]
<jmercouris>
fourier: What?
<shka>
one for GUI, one for everything else that may block
<shka>
or takes time to finish
<fourier>
maybe i dont understand the problem :(
<jmercouris>
shka: Given this very simple function: (defun name-food (name food) (print name) (print food))
<jmercouris>
how would you chain the prompts for both inputs?
<shka>
and where is my gui?
<shka>
i would start with (curry #'name-food name food)
<jmercouris>
What about something like this? (:inputs (:food) (:name) food-name)
<jmercouris>
Lol, THAT'S HILARIOUS!
<shka>
this is not a joke
<jmercouris>
Yeah, I know what currying is, but that's just a hilarious coincidence
<shka>
well
<shka>
ok
<jmercouris>
okay, here's a slightly more tricky scenario
<jmercouris>
You want to get input B, IFF input A is some value
<jmercouris>
I don't see how you could chain asynchronously in this case
<shka>
where is input B?
<jmercouris>
shka: Let me put it as a defun so it makes more sense, one sec
JohnnyL has quit [Quit: leaving]
<shka>
if you have some sort of OK button, i don't see a problem
Tobbi has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<jmercouris>
of course this example is quite trivial and doesn't require chaining, but what if the second input depended on the first in some way
fikka has joined #lisp
<shka>
minibuffer uses enter for confirmation right?
<jmercouris>
what if the auto-complete suggestions of the second input depend upon the first
<jmercouris>
shka: Yes
attila_lendvai has quit [Ping timeout: 272 seconds]
<shka>
then just slap history in the state and be done with it
<shka>
don't make it complicated
Guest51695 has quit [Ping timeout: 265 seconds]
<jmercouris>
I'm trying to make it simple actually :D
<jmercouris>
I'm just thinking about how users may write functions
<shka>
other than that
<shka>
launching name-food first asks about name, then about food, right?
<jmercouris>
shka: that's the idea
<jmercouris>
but the function should be able to be given name and then do any arbitrary processing before asking about food
<shka>
still, don't block
<shka>
use CPS and stuff
<jmercouris>
I mean certainly one could write a function like (defun name (name)) and then (defun name-food (name food)) where after executing name, it would call name-food with the value of name, but passing state between those two defuns would be exceptionally complex
<jmercouris>
shka: CPS?
<shka>
continuation passing style
<shka>
on lisp explains it
<jmercouris>
yeah, I'm looking at the wiki article
<jmercouris>
I get it
<jmercouris>
that seems needless complex
<shka>
oh well
<jmercouris>
I mean compare the left hand side to the right hand side for so many of the examples :https://en.wikipedia.org/wiki/Continuation-passing_style
<jmercouris>
I feel like this imposes too great a burden upon people using my program
<jmercouris>
maybe there is a way I can write a macro that intelligently breaks apart calls somehow to avoid blocking
<jmercouris>
without putting a huge burden on my end user
<nyef``>
Heh. And the occasionally-tried approach of doing the CPS-conversion automatically has its own drawbacks.
smurfrobot has quit [Remote host closed the connection]
<shka>
yes
<shka>
in fact i think it is more problem then it is worth
<shka>
on-lisp style macros is as far as i would go
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fikka has quit [Ping timeout: 272 seconds]
<jmercouris>
shka: Concurrency is its own kind of bullshit, but maybe I don't have to worry about that, when the system is getting input, maybe it should block
pmetzger has quit [Ping timeout: 263 seconds]
<jmercouris>
I obviously can't block on the GUI thread, but yeah
<shka>
riiiiiiiiiight
<shka>
:P
<jmercouris>
ah shit, if a function from the GUI thread were to call for input, that would be a disaster
<jmercouris>
If I recompile, that warning goes away
<jmercouris>
I am growing more confident of dyslexia with time, s/undelcared/undeclared
<fourier>
im more interested in something like rxjava though, of the same quality. they took it into java9 now. I started to look at series thinking it is something similar but it is not (and cells is a dead project)
<fourier>
jmercouris: because next-application is not a variable?
<jmercouris>
ah yes, indeed, thank you
<jmercouris>
maybe I should spend less hours per day programming
<aeth>
Hmm... looks like on the surface, series conforms to what I think is the way to write efficient CL, i.e. macros, not higher order functions.
<aeth>
Feel free to make the macros look like higher order functions, of course.
fikka has quit [Ping timeout: 264 seconds]
malcom2073 has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<aeth>
oh, hmm, it can take lambdas
random-nick has quit [Remote host closed the connection]
varjag has quit [Ping timeout: 256 seconds]
<fourier>
it depends on a situation I guess, mostly not (hard to debug, etc) but for a general-purpose framework with the focus on optimization is a right way to go.
red-dot has joined #lisp
<aeth>
Well, I don't think all CL has to be fast CL.
<akkad>
fast is the only measurable item noobs can grok
<aeth>
There are three easily measurable things: speed, consing, and conciseness
<|3b|>
not all code has to be measured for noobs :)
<aeth>
Advanced mode is figuring out cache misses
<aeth>
I don't even know where you'd start, there.
mepian has joined #lisp
Danishman has joined #lisp
<akkad>
more like cpi
fikka has joined #lisp
damke has joined #lisp
knobo1 has quit [Ping timeout: 260 seconds]
damke_ has quit [Ping timeout: 264 seconds]
varjag has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
dieggsy has joined #lisp
asarch has quit [Quit: Leaving]
dieggsy has quit [Client Quit]
smurfrobot has joined #lisp
malice has quit [Remote host closed the connection]
serviteur has quit [Read error: Connection reset by peer]
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 264 seconds]
random-nick has joined #lisp
pierpa has joined #lisp
<fiddlerwoaroof>
fourier: you might look at cells
<fiddlerwoaroof>
It might be "dead", but it works pretty well
<fiddlerwoaroof>
I think it's more "finished" than "dead": if I'm not mistaken, Kenny Tilton still uses it for things like his algebra-teaching site
<fiddlerwoaroof>
The biggest issue with it is that there's little to no documentation
<fourier>
ive seen it, and i wrote about "quality" :)
<fourier>
documentation is a measure of quality for me.
safe has quit [Quit: Leaving]
<akkad>
T
fikka has quit [Ping timeout: 272 seconds]
smurfrobot has joined #lisp
<fiddlerwoaroof>
I disagree, the skills and aptitude for writing documentation are different from the skills necessary to write good software.
<fiddlerwoaroof>
I have used plenty of good libraries with horrible documentation and plenty of bad libraries with ok documentation
Karl_Dscc has joined #lisp
Tristam has quit [Ping timeout: 248 seconds]
<shka>
writing documentation is hard
<shka>
really hard
<jackdaniel>
no, it just takes time which people are not willing to spend on writing docs
fikka has joined #lisp
<fiddlerwoaroof>
Yeah, this is one of the impressive things about Shinmera's libraries: they are pleasant to use, and the documentation is really nice
MochaLoca is now known as Sauvin
<jackdaniel>
it is not hard to write OK documentation when you create a project, it is hard to mobilize yourself to do it
<fiddlerwoaroof>
What makes documentation hard is understanding what newcomers to your project need to know
<fiddlerwoaroof>
For really simple libraries that do one obvious thing, it's not that difficult
<fiddlerwoaroof>
But for complicated libraries, it's extremely difficult for someone familiar with the project to understand the perspective of a newcomer.
<jackdaniel>
simply outlining most important concepts and how they fit together makes OK documentation
<jackdaniel>
introduction for beginners makes it better
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<shka>
jackdaniel: it is damn hard for me
marvin3 has quit [Remote host closed the connection]
<fiddlerwoaroof>
Also, it's hard for people who do something well to understand how difficult it is to do what they do :)
fikka has quit [Ping timeout: 256 seconds]
<jackdaniel>
that's why you are not documenting parts you find hard but concepts. but I may be very well wrong, I'm speaking of my intuition (which whispers – it's laziness not a technical problem to write a documentation)
<jmercouris>
Agreed, writing documentation is not hard, it's just hard to do
<jmercouris>
The biggest issue with documentation is forgetting everything you know, but remembering it at the same time so that you can write complete documentation, but understand what your users may be missing
<jmercouris>
You have to be able to paint the whole picture, and make no assumptions about the users' knowledge (except for some basic assumptions, which have to depend on a per project basis/target users)
megalography has quit [Read error: Connection reset by peer]
<TMA>
jmercouris: it is very hard to make those exceptional assumptions correctly.
sz0 has quit [Quit: Connection closed for inactivity]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
nirved has quit [Quit: Leaving]
<aeth>
The problem with documentation is that it can easily become considerably out of date.
<Shinmera>
fiddlerwoaroof: Why thank you
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
zooey has quit [Ping timeout: 248 seconds]
zooey has joined #lisp
<jmercouris>
TMA: Yeah, and that's one of the key differences between good/bad documentation, a good way around this is to constantly have noobs proof-read your docs and see where they have problems
<TMA>
good examples are beneficial too -- where "good" means: showcasing the typical usage (if it is typical to have more than one instance of THINGAMAJIC, make the example use at least two, not one. if it is idiomatic to do it one way, do not do it another way in the example); good examples are partially overlapping. (one uses A and B and showcases their interaction, other example showcases A and C)
<aeth>
TMA: That's why I think an examples directory is often better than traditional documentation, as long as the examples are heavily commented
<jmercouris>
aeth: It really depends on the software, whether it is a library or a user-facing GUI application
<aeth>
Not just a documentation example, but something that will break if someone forgot to update it.
<jmercouris>
aeth: It's not easy to convey the workflows of a GUI in plain-text in an exmaples dir
fikka has joined #lisp
<jmercouris>
aeth: I would agree though, for libs, I always look at the examples that come with it rather than some terse documentation
<jmercouris>
Or a tutorial, tutorials are always really good, because they are like an example, but with explanations
<TMA>
the examples provide a roadmap. then there needs to be a reference documentation, that can be as dry as required. it is important to document all the dark corners too ("although the type is (unsigned-byte 8) only powers of two are valid values")
<jmercouris>
TMA: The reference code is in the docstrings, hence this big debate yesterday or two days ago about formatting docstrings :D
<shka>
on the other hand
<shka>
I find writing documentation inspiring for design
<aeth>
Sometimes you do need a ton of documentation including a full reference, e.g. if you're writing your own loop-like macro
<aeth>
Because then you're effectively writing your own language
<jmercouris>
shka: Super true, you realize the shortcomings of your API when you are forced to use it as an outsider
<jmercouris>
or rather, forced to talk about it ala rubber duck
marvin3 has joined #lisp
<shka>
and realize that it is just suboptimal?
<shka>
yes
<aeth>
jmercouris: well the examples directory is what being forced to use it as an outsider is
<shka>
i have a lot of that :P
<aeth>
documentation's just describing it to an outsider
<jmercouris>
aeth: I take back what I said, yes I agree more with that
<aeth>
Too many example directories aren't commented, though, because the author thinks they're self-documenting.
<aeth>
Examples are the one case where you want to be as verbose as possible in comments imo
<shka>
someday i will be smart enough to write largeish system without instant urge to scrap everything and start all over again :P
fikka has quit [Ping timeout: 272 seconds]
<jmercouris>
I like the term "self-documenting" that's some good irony right there
<aeth>
Examples should be commented heavily just in case the reader looks nowhere else
<jmercouris>
shka: Nobody is ever that smart, writing a large system involves constant incremental refactoring
<shka>
jmercouris: JUST LET ME BELIEVE!
<jmercouris>
Nobody can make a grand plan for a large piece of software in their heads, in the 90s, big fad of so-called "architects", that didn't pan out so well
<aeth>
You can write a large system, in pieces, without any major refactorings or mistakes if you pick something very well defined, e.g. if you wanted to write your own emacs.
<jmercouris>
Especially because you'd have to nail down the business requirements before you even started programming- which of course will change throughout the course of programming
tom34 has joined #lisp
fikka has joined #lisp
<jmercouris>
You might be able to, if your task was very well defined beforehand, but that's so rare
<TMA>
jmercouris: writing a large system involves mainly code duplication (you cannot modify the code, because you do not know which other parts depend on the quirks/bugs contained therein)
<jmercouris>
TMA: Among other things, yeah
<jmercouris>
basically you feel as if you cannot trust any of the existing API (particularly in "legacy" systems)
<aeth>
all systems are legacy systems except the ones we're writing right now
<jmercouris>
shka: I've decided to try a blocking design btw, I think I will spawn a new thread every time minibuffer input is requested
<TMA>
every system becomes a "legacy" system the next day after it's installed
<jmercouris>
I associate the word "legacy" with "unmaintained" a similarly nebulous term, frequently of debate on this channel :D
<jmercouris>
I'm always imagining some crufty cobol code mixed with perl on some IBM mainframe that some poor developer has to maintain lol
<aeth>
jmercouris: Write a perl->CL compiler!
<jmercouris>
and then on top of that the "front-end" team, has setup a REACT NATIVE application after they rewrote the meteor one, and now they are moving to JS ES6... etc
<jmercouris>
aeth: I luckily don't have this problem, but if I did, I might look at a way to make perl and cl interop lol
<fourier>
i cant believe the necessity of quality documentation is even a topic of discussion
random-nick has quit [Remote host closed the connection]
<jmercouris>
fourier: It's not that there isn't a consensus, it's just a cathartic release, personally it doesn't bother me at all, I prefer the channel to be a little active
<fourier>
for example i never used cells and will never use just because its a) lacks of documentation b) no active community
<fourier>
even if it does the same thing as rxjava does, i have no way to find it out without spending a couple of days digging into its internals.
<_death>
there is a cells tutorial
<_death>
and you shouldn't be afraid of source code :)
<fourier>
on the other side, series, even if it doesnt help in this sense, have 2 papers describing it and a chapter in CLTLv2
<fourier>
if the authers didnt bother with the doc i assume the quality of the source code as well
<fourier>
why the hell you will write explanations and a good design if you can just hack some shit together and live with it ?
eudoxia has quit [Remote host closed the connection]
eudoxia has joined #lisp
Jesin has quit [Quit: Leaving]
<fourier>
meaning if you dont bother about potential users why should you bother about someone reading your code.
<_death>
on the flip side, writing documentation stabilizes design, even if it's bad
<fourier>
sure but the job is not done if there is no documentation. writing it is a part of getting things done.
<fourier>
otherwise "not stabilized designt
<fourier>
" is not something to be used by other people anyway
<_death>
well, I think Tilton wrote it for his own use
<aeth>
_death: no, writing documentation doesn't stabilize the design. The design can change heavily, and paragraphs can then be completely wrong
Jesin has joined #lisp
<_death>
aeth: right.. it was more about my attitude towards documentation (and tests..) rather than a general remark on how things are
shka has quit [Ping timeout: 260 seconds]
<fourier>
thats why it is not widely used. just hacked away. documentation page on tilton-technology.com is 404, and the project is dead when its author lost interest.
orivej has quit [Ping timeout: 260 seconds]
<_death>
fourier: sure.. many projects are like that.. doesn't mean they're useless for everyone
<jmercouris>
Lots of code doesn't need an active community
<jmercouris>
for example, many testing libs do not need to be updated/active
<fourier>
sure there are someone who had started to use it before.
<jmercouris>
it wouldn't make them better or worst
<jmercouris>
s/worst/worse
<_death>
fourier: don't see any CL library there
<whoman>
^_^
<fourier>
_death: exactly :)
LiamH has quit [Ping timeout: 264 seconds]
<fourier>
jmercouris: but they better to be active? i reported a bug bothering me to cl-prove and didnt get any attention, so i just dont use this particular part of functionality
<fourier>
so if things like this continue i'll roll on my own library, fragmenting community even more
<Shinmera>
I'd like to say that Parachute has a much more justifiable reason to exist than a lot of the others out there
<jmercouris>
Shinmera: What's the reason?
<fourier>
i guess main reason is because Shinmera is an active developer and will probably fix the bugs ;)
<Shinmera>
It's intended to be extensible and all-encompassing.
<Shinmera>
Part of the proof of that is that it has compatibility layers for the syntax and behaviour of other testing frameworks
<whoman>
o jeez abstract that away much, everythings intended extensible and all-encompassing =P
<jmercouris>
A meta testing framework if you will
* whoman
o
<jmercouris>
A framework that can leverage other frameworks
<Shinmera>
jmercouris: Eh, it's more that it just has a protocol for how tests are defined and executed.
<_death>
fourier: personally I took all quicklisp projects I have that have a git repo and cloned them into a third-party directory.. every once in a while I fetch all and review the new commits.. when something isn't right, I just patch it.. so it works for me.. the extra work w/ pull requests and discussion etc. is a different matter with differnet priority
<jmercouris>
interesting
<jmercouris>
I was thinking about using Parachute, but I'm a long way from actually writing tests...
<whoman>
_death, your own projects or in general? why ?
<jmercouris>
I wish that there wre "lisp community owned" projects
<fourier>
_death: maybe you have a full-time lisp job? when having family/kids and having 1-2 hours every other day for some coding its not really a viable option
<jmercouris>
so that we didn't have to rely on maintainers
<Shinmera>
jmercouris: There is no lisp community, so
<jmercouris>
Shinmera: Yes there is
<jmercouris>
What are the people on this channel?
<_death>
whoman: my own projects already live in local-projects, talking about everything else.. why? so that my threshold for patching 3rd party code is basically zero
LiamH has joined #lisp
<jmercouris>
So every popular quicklisp repo could have a "Lisp community version" which can pull upstream from the official version and accept patches from others
<jmercouris>
maybe maintainers wouldn't like to lose control though
<fourier>
I typically just use the stuff from quicklisp, and if have a problem trying to search on github for this project, fork it and suggest a fix. that is why I even reported a feature request to Xach so I can get the source repository url straight away from repl without getting to quickdocs etc.
Amplituhedron has joined #lisp
<_death>
fourier: right, it works for me..
<Shinmera>
aeth: sharplispers is run by a select few lispers, and lispgames is run by the lisp games channel. Neither are run by "the lisp community."
Kundry_Wag has quit [Remote host closed the connection]
<jmercouris>
Is anyone willing to join a Lisp community to fork and maintain orphaned projects? If so, I would volunteer in starting the org and adding members/promoting it etc
<whoman>
_death, ohh, interesting =) going to keep that strategy in mind
Kundry_Wag has joined #lisp
<fourier>
I think people already do it with stuff like zlib etc
<fourier>
are they sharplispers? dont remember
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<whoman>
i am down for that, but hmm
<fiddlerwoaroof>
Actually, there is a fairly complete document about cells
<fiddlerwoaroof>
It's a pain to find, but it's fairly complete
<jmercouris>
whoman: What's your name on github?
Kundry_Wag has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof>
If you look at the cliki page for cells, that documentation is linked
pedh has joined #lisp
<fourier>
ok i see
<whoman>
jmercouris, used to be humasect, lost password, now is quakerquickoats
Amplituhedron has quit [Ping timeout: 256 seconds]
ebzzry has joined #lisp
<Shinmera>
jmercouris: Please take over all my projects now, tia
pedh has quit [Ping timeout: 260 seconds]
Amplituhedron has joined #lisp
pedh has joined #lisp
turkja has joined #lisp
pedh has quit [Ping timeout: 272 seconds]
milanj has joined #lisp
orivej has joined #lisp
ebzzry has quit [Quit: WeeChat 1.9.1]
hobbit|o746 has joined #lisp
<hobbit|o746>
▄▄▄▄▄▄▄▄▄▄▄▄▄▄ DID YOU GUYS KNOW TODAY WAS NIGGERS DAY?? SAY HI TO YOUR FAVORITY NIGGER IN #FREENODE!! quicktalkeh676te.onionufpsgdenhk: Intensity pjb mepian turkja attila_lendvai fikka pseudonymous Karl_Dscc damke smurfrobot AntiSpamMeta lagagain red-dot Danishman malcom2073 groovy2shoes jmercouris EvW1 peccu3 Kevslinger Jesin megalography dliot Amplituhedron te
<hobbit|o746>
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ DID YOU GUYS KNOW TODAY WAS NIGGERS DAY?? SAY HI TO YOUR FAVORITY NIGGER IN #FREENODE!! quicktalkeh676te.onionxayskabq: fikka rotty tom34 red-dot attila_lendvai orivej atgreen Bike wigust_ SuperJen damke rpg eudoxia milanj Intensity jmercouris Kevslinger pseudonymous terpri marvin3 josema pmetzger Karl_Dscc Amplituhedron mepian
hobbit|o746 has quit [Killed (Sigyn (Spam is off topic on freenode.))]
Kevslinger has left #lisp [#lisp]
megalography has left #lisp [#lisp]
dliot has quit [Quit: dliot]
<jmercouris>
Shinmera: Lol
<jmercouris>
I hope this spam isn't getting persisted to the IRC Log
<Shinmera>
It is
impulse has quit [Quit: Lost terminal]
<jmercouris>
This kind of thing should be wipable, I don't think this is good content to save
<pmetzger>
Meh, it's obviously spam.
<Shinmera>
I'm fine with it being impartial to what's on the log.
<pmetzger>
The more interesting question is chasing them down and telling the 12 year old's mom what he's been doing online.
<jmercouris>
It is, but it somehow makes my computer feel dirty even having it on my screen
<Shinmera>
There's /clear if you're that sensitive to words
<pmetzger>
isn't that client dependent?
* Cthulhux`
wrote an adiirc/mirc script that can filter lines with certain words
<Cthulhux`>
(but i seriously wonder if so many people are THAT sensitive)
<Shinmera>
pmetzger: Pretty much every client has a clear command
<pmetzger>
what's the syntax?
impulse has joined #lisp
earl-ducaine has quit [Remote host closed the connection]
dtornabene has joined #lisp
earl-ducaine has joined #lisp
wxie has joined #lisp
<jmercouris>
whoman: If I make the group, I'll add you
<whoman>
alright thank you :) i hope to have my project(s) cleaned up soon
impulse has quit [Client Quit]
<jmercouris>
Lol, that's not the idea I had in mind, it's not to drop off your own projects, I thought we could pick up projects which aren't responding to pull requests etc, and accept/patch them etc
<jmercouris>
someone to review and keep things up to date
<jmercouris>
(defun jmercouris () ;; code for spin lock)
eudoxia has quit [Read error: Connection reset by peer]
<Shinmera>
(loop) woulda been shorter
<lagagain>
What's the code want to do ? Use at this chatroom ?
wxie has quit [Quit: Bye.]
<_death>
it just suggests an order for considering projects
dieggsy has joined #lisp
<jmercouris>
Shinmera: I know, but spin-lock is funnier, it won't release to any other thread
Kundry_Wag has joined #lisp
GreaseMonkey has quit [K-Lined]
brandonz has quit [K-Lined]
orivej has quit [Write error: Connection reset by peer]
orivej_ has joined #lisp
<whoman>
jmercouris, sorry i know =) just speaking out loud to remind myself under the pressure of peers
pseudonymous has quit [Remote host closed the connection]
pseudonymous has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
brandonz has joined #lisp
Amplituhedron has quit [Read error: Connection reset by peer]
greaser|q has joined #lisp
pseudonymous has quit [Remote host closed the connection]
pseudonymous has joined #lisp
Amplituhedron has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
<rpg>
fourier: ABCL is good for lightweight JVM scripting, but it's too inefficient for use as one's main implementation.
<rpg>
fiddlerwoaroof: AFAIK jfli is unmaintained and bitrotted
jmercouris has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
* rpg
has a lot of catching up to do.
damke has quit [Ping timeout: 264 seconds]
pseudonymous has quit [Ping timeout: 272 seconds]
quazimodo has joined #lisp
tom34 has quit [Ping timeout: 272 seconds]
<earl-ducaine>
Lispologists! q: what are the various opinions on the conventional usage of -p, e.g. blah-blah-blah-blah-blah-p
<earl-ducaine>
*said in the voice of rhiana*
<earl-ducaine>
Should it only be a function, or is it acceptable to use as the name of t/nil variable?
Kaisyu7 has quit [Quit: WeeChat 1.4]
pedh has joined #lisp
<earl-ducaine>
I would have thought the former (only as a function, maybe macro), but I've seen many instance of it being used as variable.
Jen has joined #lisp
Kaisyu has joined #lisp
Jen is now known as Guest11827
Kaisyu7 has joined #lisp
<fourier>
rpg: then lw is a good option, the integration with jvm is real good (for example I was able to use fantastic java joda datetime library from CL in LW)
JenElizabeth has joined #lisp
pedh has quit [Ping timeout: 264 seconds]
SuperJen has quit [Ping timeout: 265 seconds]
Folkol has quit [Ping timeout: 240 seconds]
<rpg>
fourier: the integration in Allegro is also good. But, to be honest, integration with the JVM is always going to be nasty -- because it's a virtual machine, and a lisp image is almost a VM itself, the easiest way to integrate is some form of remote procedure call, which is very heavyweight. I think that's more Java's fault than anyone else's. It's pretty much the same for .NET
<_death>
earl-ducaine: the P is for predicate.. a boolean variable is not a predicate
Guest11827 has quit [Ping timeout: 240 seconds]
<earl-ducaine>
_death: I'm showing my appalling ignorance... But I've never understood what was 'predicat' about how -p is used. (i.e. how it would be realated to the verb object part of an english sence, the only usage of the word i'm familiar with.)
malice has joined #lisp
<earl-ducaine>
So, perhaps I should clarify my question: how in practice do you use it, or expect it to be used.
<fourier>
rpg: yep but even it is bulky it works, and works pretty well. at least it is integration! Its really sad though what abcl doesn't get much traction, its the reason to choose clojure on jvm as a jvm-compatible lisp. Also there is not much information on how to embed abcl into the java developer's workflow, like ant/maven/gradle integration so I can quickly drop it as a dependency to my say Android project to use it for code
<_death>
earl-ducaine: it comes from formal logic, meaning a function that maps to a boolean
<rpg>
fourier: I used it quite successfully as a way to explore and then extend a very large Java system. But I did end up taking the code originally written and tested in ABCL and then translating it into Java with Eclipse.
<fourier>
oh man. why so ?
<_death>
earl-ducaine: you could say the boolean variable is a way to write a nullary function, but I don't see it as good style
<fourier>
also when the #lisp will migrate to mattermost or something modern ? :)
<earl-ducaine>
_death: Thanks. Reading the wikipedia article on logical predicates (I didn't know, though I should have guessed) that's what they were named from, it seems that both interpretation i.e. a function or variable *could* be justified, at least for a simpleton such as myself.
Zakkor has joined #lisp
<earl-ducaine>
But your preference is noted.
dtornabene has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
DeadTrickster has quit [Read error: Connection reset by peer]
DeadTrickster has joined #lisp
fourier has quit [Ping timeout: 240 seconds]
<Fare>
rpg: I sent another MR on gitlab, for source-location for define-package on SBCL
astronavt has joined #lisp
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
orivej_ is now known as orivej
turkja has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Tristam has joined #lisp
<fiddlerwoaroof>
rpg: hmm, it looked to me like it was semi-maintained, on ccl at least
<fiddlerwoaroof>
Also, integrating ABCL in a java project is pretty straightforward: I spent an hour or so playing around with it, and it wasn't too difficult to figure out how to embed it in a java application.
vaporatorius__ has joined #lisp
nimiux has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Ping timeout: 272 seconds]
<fiddlerwoaroof>
Maybe I'll dig my sample out of my work laptop sometime.
tom34 has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]