varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
akoana has joined #lisp
<badcfe>
am i wrong in assuming i can become fluent in common lisp, and go ahead and write whatever program in common lisp? someone mentioned it was more of a methematical thingy, not for humans ...
<phoe>
what
<jasom>
badcfe: yes, you can go ahead and write whatever program in common lisp
<phoe>
Lisp is a language for humans
<phoe>
and a pretty nice and useful and interactive one, to add.
<oni-on-ion>
it is much more for humans than most other programming languages, for sure.
patrickp has left #lisp ["Shuting down..."]
<oni-on-ion>
(ironically one of the reasons it is not my #1)
<badcfe>
the restart facility just bothers me, because i dont appretiate its value.
<phoe>
don't use it, then
<phoe>
you might appreciate it e.g. when you end up in the debugger but don't want to kill the lisp process
<phoe>
or when you want to gracefully recover from some error situation without breaking it altogether.
<badcfe>
but it's extremely interesting, and surprising this kind of thing doesnt exist in other langs/envs
<phoe>
they don't find much value in interactive restarting facilities because they usually have no interactivity baked into the language
<badcfe>
i just dont have it in my workflow or something like that
<phoe>
same with programmatic recovery actions.
<phoe>
usually it's "oh shit, we're dead, throw an exception and hope something catches it"
<badcfe>
so it was impossible to inherit this nice restart concept in other langs/envs?
<phoe>
badcfe: it's possible to implement it in other languages as a library
<phoe>
uh, sure? it implements common lisp, so it has restarts too
<badcfe>
no. i meant common lisp
<phoe>
oh, that's a different thing
<phoe>
yes
<phoe>
you can use functions COMPUTE-RESTARTS and FIND-RESTART to grab a hold of a restart object
<badcfe>
phoe: you refer to gnu with clisp right?
<phoe>
and then use INVOKE-RESTART or INVOKE-RESTART-INTERACTIVELY to call it
<phoe>
badcfe: yes, I refer to the GNU CLISP implementation when I think "CLISP"
<phoe>
CLISP is not a good acronym for Common Lisp though; CL is better.
<badcfe>
is programatic restart the way to go in c-lisp, as kind of an exception handling, but where the throw-site defines teh action
<badcfe>
i'll use CL to refer to common lisp from now on
<phoe>
I need to run to sleep now
<phoe>
so I can't provide in-depth answers
<badcfe>
don't run to hard .. it might take away potential for good sleep
<phoe>
if you're fine with grabbing a book, I can point you towards "The Common Lisp Condition System" that describes restarts as well as conditions and handlers
<phoe>
:D
<phoe>
;; warning: the book is by me, so this is a shameless plug
skapata has quit [Remote host closed the connection]
jibanes has joined #lisp
thecoffemaker has quit [Quit: So long and thanks for all the fish!]
thecoffemaker has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
nij has joined #lisp
imode has joined #lisp
dbotton has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
bilegeek_ has joined #lisp
jprajzne has quit [Quit: jprajzne]
Stanley00 has joined #lisp
<nij>
I have a common lisp file that is growing, and getting messier. I don't mean to package it, but have a need to separate the codes into different files. What's the next step I should look into? Should I start learning how to use ASD?
Stanley00 has quit [Remote host closed the connection]
bilegeek has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
Usually you have files in packages, then packages in systems. But then you load all the files with an ASDF system.
<nij>
Hm! OK It seems the right time for me to know all these things anyway: a file, a package, a file, and an ASDF system. I know where to look into these :) Thanks!!!
<badcfe>
the set of function in onlisp seems practical to have. is there a package that has this, or only his source which was extracted from the latix and has a copiright notice that makes it feel like i should not fix up the mentioned problems with CTL1 and redefinitions
<nij>
Any hope to deal with common lisp smoothly without using emacs? Just curious as my friend is asking.
<badcfe>
s/function/lisp functions and macros/
<no-defun-allowed>
There's SLIMV for Vim and something for Atom too.
<nij>
Nice. I need to brainwash him to use vim first anyways.
jprajzne has joined #lisp
<PuercoPop>
nij: yeah, defining a system sounds like a good idea. You can start with $ echo '(defsystem "foo" :components ((:file "foo")))' > foo.asd
wxie has joined #lisp
nij has quit [Ping timeout: 258 seconds]
orivej_ has joined #lisp
orivej has quit [Read error: Connection reset by peer]
Lord_of_Life_ has joined #lisp
jibanes has quit [Ping timeout: 260 seconds]
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
jibanes has joined #lisp
epony has quit [Quit: upgrades]
rogersm has joined #lisp
<entre-parenteses>
nlj: If you're planning to brainwash him to use Vim anyways, you could always try to get him hooked on Spacemacs - https://www.spacemacs.org/
<entre-parenteses>
* nij:
<entre-parenteses>
Then you'd get him hooked on Emacs *and* Vim ;D
<badcfe>
is this spacemacs built on emacs and has the elisp inside?
rogersm has quit [Ping timeout: 260 seconds]
<badcfe>
is there a hello world lisp system containing asd and all, kind of a template project to start with?
<badcfe>
also, i wonder how to kind of "make" the system into an executable.
<badcfe>
wow in sbcl i did (ql:quickload :ltk) and then (in-package :ltk) and then i can program all these GUI things, nice
<curiouscain>
I think (asdf:make) will trigger it, but I can't remember
jprajzne has quit [Quit: jprajzne]
<badcfe>
my problem is, if i learn this, then snap! and it becomes unmaintained and unavailable
<lotuseater>
badcfe: then you have a way better chance (and maybe more awesome experience) with McCLIM
<badcfe>
but it will go away again faster than something based on TK i would think
defunkydrummer has joined #lisp
<lotuseater>
ehm no, McCLIM not
<no-defun-allowed>
I don't think Tk is going away soon.
<badcfe>
tk is decent. i dont like flies that snapps hype and then dies
<solideogloria[m]>
I just use cl-cffi-gtk
<defunkydrummer>
no-defun-allowed: tk got a new life lease thanks to Python (TkInter). It is also rather easy to use.
<badcfe>
cffi to gtk sounds like a decent approach
<defunkydrummer>
I like LTK.
<defunkydrummer>
LTK works fine and it's multiplatform
<defunkydrummer>
fine for simple UIs
<badcfe>
i had some fun with tcltk way back
<badcfe>
and also py tkinter yes
EvW has quit [Ping timeout: 258 seconds]
jprajzne has joined #lisp
<badcfe>
ltk seems good, but should i take last update 2006 as a bad sign. or not
<no-defun-allowed>
Again, Tk isn't going anywhere, so there's no reason for it to be bad.
<badcfe>
maybe bindings to ltk is not problematic, and this package will stay around. i dont even know about this quicklisp ecosystem, im not confident to rely on these things.
<lotuseater>
badcfe: don't worry, there is so much stuff
<solideogloria[m]>
it has some on the cairo stuff
<defunkydrummer>
badcfe: bad sign, why?
<defunkydrummer>
badcfe: tk hasn't changed and lisp neither
<defunkydrummer>
badcfe: and besides that, it has been maintained on github, I'm certain last commit isn't that old, perhaps 2018
<badcfe>
defunkydrummer: but how can i be confident some module that i get my hands on through this quicklisp today will be available forward
<solideogloria[m]>
depends on the module
kaftejiman__ has quit [Remote host closed the connection]
<badcfe>
defunkydrummer: maybe with lisp its easier to grab some lisp system and it will work without a bunch of various broken system deps and things
<solideogloria[m]>
tk isn't going to go away because of python
<curiouscain>
Unless it fails to compile or is devoid of features, I think that's not a worry you really need to have
<lotuseater>
badcfe: phew one can really tell that you are a newbie :)
<defunkydrummer>
badcfe: i don't understand your concerns. How is this different to using an external dependency on any other language?
<defunkydrummer>
lotuseater: let's be kind to newbies
<lotuseater>
defunkydrummer: it was meant very kind!
<badcfe>
wow, that cl-cffi-gtk has WAY more contents and deps than the ltk
<solideogloria[m]>
well it is gtk at the end of the day which is huge of itself
<solideogloria[m]>
* well it is gtk at the end of the day which is huge
<badcfe>
(defcstruct g-object-class ... wow this is advanced stuff
<solideogloria[m]>
glib stuff
<badcfe>
really wrapping gtk decently. and it has some bordeaux threads thing inside there?
<solideogloria[m]>
glib has its own threading stuff iirc
<badcfe>
so i'm guessing lisp structures are used as builders of the gobjects and structures in the gui event loop here, and on callbacks there are lisp accessors to the gui engine things
<solideogloria[m]>
to gtk libraries, yes
<solideogloria[m]>
it's cffi
<badcfe>
so lisp is kind of arm-waving at, and getting shadows from, the gui engine including those gobjects and all
<solideogloria[m]>
kind of, yes
<badcfe>
facinating. i am positively surprised.
<badcfe>
this could be a motivator to play a little more with lisp here. have fun
<lotuseater>
you have this with CFFI in general :)
<badcfe>
s/have fun/to have fun exploring this and building some neat thing as a side effect/
<solideogloria[m]>
yeah, its the same thing for libaries using CFFI
<badcfe>
is there some hello world around? kind of a template project i could start with?
<solideogloria[m]>
interfacing with the C libraries with lisp and giving bindings for their respective stuff in C
<solideogloria[m]>
just substitute asdf:load-system with ql:quickload
jibanes has quit [Ping timeout: 260 seconds]
jibanes has joined #lisp
<badcfe>
debugger invoked on a SB-INT:SIMPLE-PROGRAM-ERROR in thread
<badcfe>
invalid number of arguments: 2
<badcfe>
#<THREAD "cl-cffi-gtk main thread" RUNNING {1007237E83}>:
orivej_ has quit [Ping timeout: 260 seconds]
<solideogloria[m]>
are you using SLIME ?
<badcfe>
hmm. i tried the A simple application. example, and (in-package :gtk) and tehn (simple-application)
<solideogloria[m]>
:gtk-tutorial, :gtk is already another package
pfdietz has joined #lisp
<solideogloria[m]>
if you are using slime, you have to do something different
<badcfe>
okay i got that window up. good
<solideogloria[m]>
nice to hear :)
Stanley00 has joined #lisp
<solideogloria[m]>
I remember that I had to do something to get it working on SLIME, can't recall what exactly
<solideogloria[m]>
when I used to use SLIME
<badcfe>
but when i try to run that gtk_class_gtk-application i get above err, and seems to have some thread due to what i observe in my job control there
<badcfe>
i use rlwrap sbcl
<badcfe>
8 - /
<defunkydrummer>
badcfe: no, it's not common
<solideogloria[m]>
<badcfe "but when i try to run that gtk_c"> gtk_class_gtk-application from the tutorial ?
<ldbeth>
no-defun-allowed: but how do you know with kind of tests are avaliable?
<no-defun-allowed>
I think you can pass any predicate function.
rogersm has joined #lisp
<no-defun-allowed>
However, I recall custom hash tables being much slower on SBCL than standard hash tables; which is a pity, because otherwise I could do (make-hash-table :test 'string= :hash-function 'djb2)
<ldbeth>
ah, i see, only the #'eql #'eq etc can be passed as argument as in CL standard, others should be passed as 'char= 'string= etc
Alfr_ has joined #lisp
dbotton has quit [Ping timeout: 260 seconds]
<beach>
Good morning everyone!
<ldbeth>
beach: heloo
Alfr has quit [Ping timeout: 258 seconds]
rogersm has quit [Ping timeout: 264 seconds]
defunkydrummer has quit [Quit: (save-lisp-and-die)]
_jrjsmrtn has quit [Ping timeout: 260 seconds]
__jrjsmrtn__ has joined #lisp
<no-defun-allowed>
Yes, only those test functions are allowed by the Common Lisp standard.
cl-arthu1 has joined #lisp
<no-defun-allowed>
But SICL hash tables and Luckless permit any hash and test functions, and are basically drop-in replacements for Common Lisp hash tables. (Except that hash functions based on the address of an object will not work in either, if your implementation moves objects.)
Stanley00 has joined #lisp
cl-arthur has quit [Ping timeout: 256 seconds]
bitmapper has quit [Quit: Connection closed for inactivity]
quazimodo has quit [Ping timeout: 246 seconds]
quazimodo has joined #lisp
<ldbeth>
no-defun-allowed: at least sxhash should be guaranteed to work
nwoob has joined #lisp
narimiran has joined #lisp
ldbeth` has joined #lisp
ldbeth has quit [Ping timeout: 256 seconds]
Bike has quit [Quit: Lost terminal]
<easye>
Mornin' #lisp. Time to make CONS.
<beach>
Hello easye.
<beach>
How are your projects going?
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
wxie has quit [Ping timeout: 256 seconds]
ldbeth` has left #lisp ["ERC (IRC client for Emacs 27.1)"]
<easye>
beach: I just joined RavenPack, so right now most of my energy is going into learning the code base.
<beach>
Oh, nice! Did you move?
<easye>
I will try to get an abcl-1.8.1 out over the holidays.
<beach>
Great!
<easye>
I am working with phoe to get ELS 2021 airborne, hopefully to get the CFP out before the holidays.
<easye>
So, a lot of stuff.
<beach>
Yes, I see.
<easye>
Moving isn't possible at the moment. I will evaluate things when the pandemic starts to tamper off, which probably won't be until late 2021.
<beach>
OK.
<easye>
But I think living in dense urban cities isn't necessarily my thing anymore, so Southern Spain sounds quite attractive at this point.
<beach>
Yeah, I wouldn't mind living there at all.
<easye>
"Cites are so 20th century" and all that.
<beach>
I agree, yes.
<saganman>
Morning beach
<beach>
easye: Where do you live now?
<easye>
Really, if I had to pick a beach, I would move in your neck of the woods, to around an hour north of Biaritz.
* easye
lives in Vienna, Austria.
<beach>
Yes, our region is pretty nice actually.
<easye>
French food, and the sheer amount of great stuff y'all have in your hypermarks is magnitudes better than what is available in Austria.
<easye>
And it has gotten much better over the last couple decades here.
<easye>
s/hypermarks/hypermarts/
<beach>
Hmm, yes, I see.
Cthulhux has quit [Quit: ne praeteriverit priusquam obesa cantaverit]
<easye>
And groceries in France are considerably cheaper than in Austria. When I have been shopping in France, a full basket of great stuff rarely breaks 100EUR. In Austria, the same stuff at less quality would easily break 300 EUR.
Cthulhux has joined #lisp
<beach>
Wow, quite a big difference.
<easye>
Yeah, I was very surprised that there is such a differential in the EU.
jprajzne has quit [Quit: jprajzne]
<easye>
And how are your projects going, beach?
<beach>
Very well thank you.
jprajzne has joined #lisp
<beach>
I just finished version 3 of the SICL bootstrapping procedure.
<beach>
Too bad it had to take three trials to get it right.
<easye>
Third time's the charm.
<beach>
But that's life. Nobody has done this before, so I had to learn by doing.
<jeosol>
Good morning all!
<beach>
Hello jeosol.
<easye>
Mornin' jeosol
<jeosol>
beach: congrats on that
<beach>
Thanks.
<jeosol>
easye, beach: hello
<beach>
There is still a lot of work left. How much is hard to say.
<jeosol>
beach: going through my CL archives, I came across a document you author, in 2000 or compiled by Loic Lacomme: "Symbolic programming using Common Lisp"
Oladon has quit [Quit: Leaving.]
<jeosol>
it does contain good points when I was trying to justify CL for choice of a project back then - I no longer do this anyway, following advice here and elsewhere
<jeosol>
beach: the bootstrapping procedure, version 3, that's also probably in the spirit of iterative CL development
<beach>
I can't remember having written that document, but I am not surprised either.
wxie has joined #lisp
<jeosol>
I think the person mentioned compiled it from notes, it seems but attributed the content to you
<beach>
jeosol: In this case, it is just that I was unable to predict the negative consequences of the choices I made for versions 1 and 2.
<beach>
Oh, I see.
<jeosol>
I see. So v1 and v2 are different from v3
<beach>
Similar in spirit, but different in the details.
<beach>
To the untrained eye, they look the same.
<jeosol>
I recently did some refactoring also using "layering" of problems and macros to automatically generate functions - always good feeling afterwards
<jeosol>
beach: oh ok. I saw a thread on reddit about parallel gc's or something a few of the lispers chiming in. Did you see it?
<jeosol>
Is parallel GC something you are looking into? FYI, I am not a compiler guy - not an expert in that space
<easye>
jeosol: Yes, I joined RavenPack at the beginning of December.
<jeosol>
Sweet. Congrats. Is this the company based in Spain? I forget
<easye>
RavenPack has a mature CL codebase with lots of stuff to learn.
<easye>
Yes, RavenPack is based in Spain. We do "sentiment analysis" of data, providing structured feeds of unstructured data.
<easye>
The bread and butter at the moment is providing machine-readable "signals" for financial news, but we are actively expanding into general analysis of textual data.
<lotuseater>
sounds nice
<easye>
It is very nice, indeed, especially after a long drought of commerical work for me personally. To be doing it in our favorite CONS makes it extra so.
<easye>
And the people at RavenPack are top-notch to boot.
jprajzne has quit [Quit: jprajzne]
<lotuseater>
oh that's a big plus. money isn't everything
zacts has joined #lisp
zacts has quit [Client Quit]
<lotuseater>
so you combine also data science and natural language processing (in text form)
<jeosol>
easye: favorite cons haha. very nice
<easye>
Exactly, and we are starting to incorporate Machine Learning for the buzzword trifecta.
<jeosol>
Are you guys using python for some of the ML work or it's all CL
jprajzne has joined #lisp
<lotuseater>
oh that buzzword is new to me
<easye>
Yes, we are using Python for Machine Learning (Tensorflow).
<jeosol>
lotuseater: which? trifecta?
<jeosol>
easye: I see, I once looked at Gabor Melis's code and I realized he integrated with python do some of the ML work.
<lotuseater>
i worked a while for a data science company where mostly python is used, the libs are very mature :)
<easye>
And we actually use Java to massage the input sources into our classifiers.
aartaka_d has joined #lisp
<lotuseater>
jeosol: yes trifecta
<jeosol>
lotuseater: true about the MLs.
<jeosol>
lotuseater: generally meaning three-pronged, three things, etc
<lotuseater>
yes and also pandas is cool for example. but back then (2018) i just was new to functional programming and far away from CL
<lotuseater>
ah okay
<jeosol>
easye: regarding your commercial statement, I seem to recall that some defense companies (US side) are using allegro works, I was in a few of their talks on Ontology and knowledge graphs
aartaka has quit [Ping timeout: 256 seconds]
<jeosol>
lotuseater: pandas is nice. I recall someone (i forgot who) was developing a similar dataframe-based library in CL and has some applications
<easye>
RavenPack is an Allegro shop. Our semantic taxonomies are mostly home-grown, mainly for efficiency/speed.
<easye>
I did a lot of semantic web research in a former life, and really like processing things with RDF, so will bring that perspective, slowly, into focus.
<lotuseater>
allegro shop?
<easye>
RavenPack uses Allegro Common Lisp exclusively.
<lotuseater>
ah ok, was too obvious so i asked :D
<lotuseater>
i never tried on one of the commercial implementations
<easye>
This is my second job using commercial implementations, the previous one was using LispWorks.
<jeosol>
I see, there's a statement by RavenPack's Jason Cornez on Franz's site
<easye>
If you have the money, and you have a job to get done, it is nice having commericial support.
<lotuseater>
i would give everything even landing one
<jeosol>
I recall the talks by Jans talked about their rdfs
<jeosol>
easye: so you'd recommend Allegro. I hear it's slower compared to SBCL, I haven't done a test.
<jeosol>
I only used it briefly many years when starting out and figuring which compiler to start using
<easye>
I wouldn't recommend anything without knowing the context (how much money do you want to spend? What are your developers used to? etc.)
<jeosol>
what about their single digit revenue "clause". I thought there was something like that. May be different now.
<easye>
SBCL is a fine implementation. GOOG uses it for the air flight search application they acquired from ITA.
<jeosol>
easye: Fair point. What I meant about recommended is all within CL sphere, and in relation to LispWorks
<easye>
jeosol: Franz is definitely the ORCL of Common Lisp implementations in terms of cost and licensing, but their support is nicer.
<jeosol>
SBCL is what I have used primarily all through
<jeosol>
easye: Thanks for that. It's good to know
<jeosol>
My contact then stressed the support part.
<easye>
Anyways, nice chatting. I'm gonna start my "commute" to work now.
<jeosol>
Safe trip. Have a nice day
<easye>
Already there--it's more of mental thing. Take care.
<jeosol>
hahaha, ok
samebchase has joined #lisp
aeth has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
aeth has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
UM-Li has joined #lisp
<no-defun-allowed>
easye: Hey, sorry for the delay, I was gardening, but using Loom is not backwards compatible with OS threads.
<no-defun-allowed>
Or, more specifically, you have the same methods to spawn OS threads, then you have another method to spawn a green thread.
akoana has quit [Quit: leaving]
<no-defun-allowed>
The change I made was to put `javaThread = Thread.startVirtualThread(r);` in the constructor for LispThread(Function, LispObject) instead of the other stuff to make a Java thread.
parjanya has joined #lisp
<easye>
no-defun-allowed: cool. Would you recommend that as the way to spawn all threads when running on Loom then?
jprajzne has quit [Quit: jprajzne]
<no-defun-allowed>
I don't see why not, currently.
<easye>
Gardening is a nice alternative.
<easye>
no-defun-allowed: Thanks. I'll get to that soon, then.
<no-defun-allowed>
But again, it's not backwards compatible with older Java, and Loom is based off a test of JDK 16, so it's not even compatible with anything stable.
rogersm has joined #lisp
<easye>
Detecting the presence of the Thread.startVirtualThread() method should be sufficient.
<easye>
Do you know if Loom openjdk16 EAs are multi-platform? (I assume you are running Linux)
jonatack has quit [Read error: Connection reset by peer]
<no-defun-allowed>
I suppose so then.
bilegeek__ has joined #lisp
bilegeek_ has quit [Ping timeout: 260 seconds]
jonatack has joined #lisp
bilegeek__ has quit [Client Quit]
rgherdt has quit [Ping timeout: 264 seconds]
frost-lab has joined #lisp
<no-defun-allowed>
easye: I still wish there was an incremental and/or concurrent _and_ generational GC on Java. The first generational collector (to my knowledge, the Liebermann-Hewitt collector) was an extension of an incremental collector (Baker copying), so this feels like a bit of a step back.
<easye>
I thought GC1 was concurrent and generational, but without realtime guarantees. But I trust you have looked at the current state of JVM GCs a lot harder than I have in recent years.
<no-defun-allowed>
G1GC? I thought it stopped the world, at least for major GCs when not apparently in a failure mode.
<no-defun-allowed>
No, it is concurrent, but I always got pauses when...using it with large heaps with...soft-realtime stuff.
<easye>
But again, my knowledge of GCs on the JVM is pretty superficial.
<easye>
And my knowledge of the taxonomy of garbage collection algorithms is even lighter.
<no-defun-allowed>
I see. I think I got a major GC every few minutes, which was no fun to play on-- er, I mean no good for my...latency-sensitive application.
<easye>
Minecraft is a perfectly good application, training the next generation of Lispers...
<easye>
If it works for Minecraft, it oughta work for HFT
jprajzne has quit [Quit: jprajzne]
<no-defun-allowed>
You got me. But a decent Minecraft modpack demands a large heap, and thus a clever GC. From what I heard, recent Minecraft conses up a lot of useless stuff like point objects, so the generational hypothesis would hold.
jprajzne has joined #lisp
<adlai>
easye: to what extent does your employer have access to the signals and classifications?
<adlai>
one pervasive idiocy in finance is that you should sell signals, instead of trading on them yourself, then your signals are worth whatever your the willing sucker pays the happy seller
<no-defun-allowed>
But my observation could have been due to swapping as well; as I mentioned a few days ago, I got more memory around the same time I got into JVM occultism. And I read that G1 only stops the world when it's completely out of memory.
<adlai>
my question could be rephrased as "Does RavenPack sell its customers the actual signals, or a tool for building their own signal classifier and alert system"
<easye>
There is nothing trivial with games, their playing, or their optimization. Conway was a famous gamer. And according to <https://en.wikipedia.org/wiki/Computability_logic> all computer programs are isomorphic to a two-player static agmes.
saganman has quit [Ping timeout: 256 seconds]
* adlai
incidentally is from the polar opposite finance dogmas, where the only possible good use of human-generated text is for consumption by humans, and anything automating human judgement is automatically suspect
<no-defun-allowed>
I had read a lot of the Handbook, but all the cool Java collectors do some clever analysis that I could describe as "they do the marking and count up the marks in regions, then lazily sweep the most unmarked regions", which I don't recall.
<easye>
adlai: RavenPack buys feeds like DowJones, and sells our own feeds enriched with semantics for the signals.
<easye>
That transformation is mostly proprietary, mainly because our customers have been interesting it things working well/fast rather than how they work.
<easye>
err "have been interested in"
<adlai>
it's also simpler to build and develop things that way
<easye>
We sell tools for enriching the signals to some extent primarily an online Juptyer-like notebook.
jprajzne has quit [Quit: jprajzne]
<easye>
But I have only been at the company for a couple weeks now, and am engaged primarily as a CL hacker, so my statements may not entirely accurate.
jprajzne has joined #lisp
<no-defun-allowed>
So what can I say, that's kinda neat. And they use mark information to decide what needs to be compacted, but moving regions and not large amounts of a heap sounds tedious.
<easye>
no-defun-allowed: What is the "Handbook" you refer to?
<no-defun-allowed>
It may be too much to hope for, but I would hope for another edition of the Handbook that covers these collectors in depth.
<no-defun-allowed>
easye: The Garbage Collection Handbook by Jones, Hosking and Moss
* easye
puts that on his reading list.
<adlai>
so RavenPack itself never touches any of the exchanges? I guess it is still possible to simulate a signal's effects, for reinforcement.
<easye>
adlai: "touching the exchanges" not as far as I know. We certainly don't have realtime/historical equity prices.
<no-defun-allowed>
beach told me that it is not the clearest to read at times, and I have to agree sadly. But it is still very useful to read.
froggey has quit [Ping timeout: 256 seconds]
mrcom has joined #lisp
<adlai>
easye: I'd expect that the market feed is an important factor for distinguishing noise about an event (where various [anti-]correlations in the time series reduce towards absolute zero), from noise about noise (where [anti-]correlations increase away from absolute zero, and you'd detect human amplification of e.g. a surprising quarterly report)
froggey has joined #lisp
<adlai>
although I am probably "teaching to the choir", here, and should go study something myself
<easye>
Well, we are just transmitting the structure of events related to companies; e.g. "Oracle just poached so-and-so as SVP of marketing from Salesforce". What these events have to pricing doesn't really factor into such knowledge. The companies which use our feeds add that sort of information.
* adlai
finds the company's pandemic dashboard... that is probably a good free demo of what your paying customers get, for other contexts
<easye>
If we added pricing information to our decision, that would presuppose a pricing model.
hugh_marera has quit [Quit: Connection closed]
<easye>
Yeah, the pandemic dashboard is a good public facing example.
jprajzne has quit [Quit: jprajzne]
<easye>
But it is an interesting line to pursue about correlations.
mbomba has joined #lisp
<adlai>
hmm, you could call yourselves a quality-pass filter between the data science garbage pipelines; although somehow "big data" is a more popular meme than "gigo" these days :(
hugh_marera has joined #lisp
* easye
just calls himself "employed" at this point.
<adlai>
I think your employer's big group photo is a good site design choice, as a background to the executive mugshots...
jprajzne has joined #lisp
<adlai>
when I see an "About Us" page that only lists half a dozen names, my own internal automated sentiment processor starts giving false positives along the lines of "wow, a statistically significant percentage of these people must have a passing familiarity with common lisp"
<adlai>
then I see the photo that enables estimating the denomenator more accurately, and laugh
UM-Li has quit [Ping timeout: 256 seconds]
andreyorst` has joined #lisp
* adlai
wonders whether the dashboard website is also built by a CL program?
<easye>
No the website is Python (Flask I believe).
<adlai>
ahh. I was gonna say, it has all the other dynamic sites that I've encountered lately completely beaten as far as working reasonably on an overworked computer
<easye>
I don't think having an entire company knowing the technology intimately is a reasonable standard. I doubt the majority of Intel knows much about chip design, lets say.
<adlai>
believe it or not, there are actually sketchy cryptocurrency bucket shops that put sentiment feeds into the same one webpage of their site that the traders use for charting and commands
<easye>
Cryptocurrency is definitely the Wild West. I had been ranging on it for the past half-decade before joining RavenPack.
<adlai>
there is not really anything to join. there are various companies although the well-managed ones are almost invariably providing services that have existed in the digital finance world for half a century, maybe more. (e.g., the kind of service your employer offers)
shka_ has joined #lisp
<easye>
The "social movement" aspect of crypto is more interesting, reminding me of the pre-commercial Internet.
<adlai>
it has been quite interesting to see how the folks who make a name for themselves doing manually, what RavenPack does programmatically, end up moving in one of two directions once they have attracted their audience
* adlai
exceeds #lisp topic by three sigma, issues ACTION to correct error
* easye
goes back to keep on being employed.
marusich has quit [Ping timeout: 258 seconds]
notzmv` has joined #lisp
mbomba has quit [Quit: WeeChat 3.0]
notzmv has quit [Ping timeout: 256 seconds]
<adlai>
let's go back to talking about garbage collection for reclamation, as opposed to filtering for noise... no-defun-allowed, I can never figure out if you are referring to "ANSI Standard Minecraft", your own client implementation, some de-facto standardized upstream client, etc
<no-defun-allowed>
X3J13 ANSI Common Minecraft
<adlai>
no-defun-allowed: I tripped up reading your previous message that "recent Minecraft... conses up a lot of point objects"
<no-defun-allowed>
Yes, I heard that Minecraft conses a lot of short-lived objects from the OptiFine developer, who was very pissy about it, and somehow didn't sound familiar with GCs at all despite what they make.
* adlai
wonders whether there's already a name existing for the subalgorithm of hash-consing, in the context of ... for lack of a more general context, flat euclidean space.
<no-defun-allowed>
They said that you have to scan all the dead objects, which no sane GC does these days.
<adlai>
so a CL minecraft client could have points use a metaclass, where allocate-instance reuses the hash-consed point objects, and behind the scenes are a handful of multidimensional bit arrays
aartaka has joined #lisp
<adlai>
... this kind of hash-point-consing, as opposed to the algorithms where you cons up points and shapes explicitly, and then end up having to maintain heaps of them, sorted by various geometrical constraints
aartaka_d has quit [Ping timeout: 260 seconds]
marusich has joined #lisp
<no-defun-allowed>
That could be doable.
<adlai>
my guess is that most who are "familiar with GCs" are familiar with them in a manner similar to the guy who drives the truck, rather than the one who troubleshoots the compactor after it stops crushing
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
aartaka has joined #lisp
<adlai>
I guess my thinking of this as related to hash-consing might be a false positive, too; because, "hash" is almost certainly the wrong metaphor in contexts where the sparse data behaves contiguously
rogersm has joined #lisp
aartaka_d has quit [Ping timeout: 260 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
aartaka_d has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 246 seconds]
<adlai>
easye: that photo probably contains ... i dunno, strictly within (3,27) common lisp programmers; although, my semantic operational conclusion is that the bus factor evidenced by that photo is "only one backpack was important enough to not be out of sight for one second, ever?"
<flip214>
which photo?
Cymew has joined #lisp
random-nick has joined #lisp
jprajzne has quit [Quit: jprajzne]
aartaka has joined #lisp
marusich has quit [Ping timeout: 260 seconds]
jprajzne has joined #lisp
marusich has joined #lisp
mfiano has joined #lisp
jprajzne has quit [Client Quit]
galex-713_ has quit [Read error: Connection reset by peer]
<adlai>
flip214: the big background image of view-source:https://www.ravenpack.com/about/ where you see dozens of people doing something outdoorsy, rather than mugshots of executives
galex-713 has joined #lisp
marusich has quit [Ping timeout: 260 seconds]
<adlai>
easye: hmmm, there is still a bit of GIGO: localizing the pandemic dashboard causes display of headlines from the english-language sites of local newspapers, and the local newspapers are garbage :)
cosimone has quit [Quit: cosimone]
marusich has joined #lisp
<adlai>
e.g., it appears that haaretz.com double-published an article with a mistake in one copy's headline; and both links appear in the dashboard.
treflip has joined #lisp
<adlai>
I guess it is a problematic error to expect that such a service would catch.
rogersm_ has joined #lisp
<adlai>
minion: memo for nij: earlier someone pointed you at chanl, for writing parallelized code; you should be warned that it is unsuitable for production use (there are a few race conditions, that should be detected by test failures)
<minion>
Remembered. I'll tell nij when he/she/it next speaks.
<adlai>
adlai: memo for adlai: the ABCL+JVM green threads might be a good choice for the next platform for hunting down the race condition
<phoe>
you likely meant minion
* adlai
forgets. He'll think through whether it's a worthwhile hunting tactic, when the bug next speaks.
rogersm_ has quit [Ping timeout: 240 seconds]
jprajzne has joined #lisp
liberliver has joined #lisp
jprajzne has quit [Client Quit]
rogersm has quit [Quit: Leaving...]
jprajzne has joined #lisp
cross has quit [Quit: Lost terminal]
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
galex-713 has quit [Ping timeout: 256 seconds]
galex-713_ has joined #lisp
a0 has joined #lisp
shka_ has quit [Quit: Konversation terminated!]
aartaka_d has joined #lisp
shka_ has joined #lisp
pve has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
nwoob has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Where do people draw the line on "large" Lisp programs? I found that my full network stack is about 8,500 lines of non-test code, and 1,300 lines of test code, and I'm worried that I've done something wrong by approaching 10,000 lines total.
<no-defun-allowed>
I don't know how many lines it should be, but it feels larger than it should be. But, then again, it's also ridiculous to me that I only wrote that much over two years.
midre has quit [Ping timeout: 260 seconds]
ljavorsk has joined #lisp
midre has joined #lisp
atomik has joined #lisp
<White_Flame>
large team commercial projects are always going to be way larger than smaller or solo codebases
<White_Flame>
since they're by default much less holistic
<no-defun-allowed>
Right.
<White_Flame>
Our biggest codebase (of multiple interconnected projects) is 30k, and does a ton
villanella has joined #lisp
<White_Flame>
*30kloc
atomik_dog has quit [Ping timeout: 264 seconds]
midre has quit [Ping timeout: 240 seconds]
<easye>
adlai: thanks for the report. I've forwarded to the pandemic dashboard group.
midre has joined #lisp
<no-defun-allowed>
I see. Part of my fear is that it's harder to sell, and no one would want to write another implementation of it. Some ACME Network Protocol supposedly requires a hundred times less code to implement; even though I think it does much less, it's not likely someone would begin duplicating a 10kLOC codebase if they want their own implementation.
<no-defun-allowed>
As in, they would be much more hesitant to pick it up as a weekend project, though I hope there isn't a need to reimplement it :)
olle has joined #lisp
ober has quit [Quit: Emacs must have died]
<adlai>
it is not a continuous topology, no-defun-allowed
<flip214>
adlai: thanks
<no-defun-allowed>
In any case, it's at a size where I'm not sure if it's too large, and I've played myself into picking up a lot of bloat; or if it's too small, and despite the time I put into it, I've been incredibly unproductive for two years.
<adlai>
e.g., 10ksloc was also a magic number that weighed heavily on my mind when I began building scalpl, and I often deleted gangrenous waste just so I could tell myself that the entire thing is less than ten thousand lines.
<adlai>
... then one day, I tried using SBCL instead of CCL, and discovered that my project also uses Ironclad... and OpenSSL!
<no-defun-allowed>
Thanks to DuckDuckGo for showing me some lovely images of gangrene, after searching for a definition of "gangrenous", as I forgot what it was.
Nilby has joined #lisp
<no-defun-allowed>
I don't have to maintain Ironclad, SBCL or OpenSSL though, and neither does some other implementor.
<adlai>
scalpl is probably the only app that uses chanl; so, is chanl's linecount tax-deductible because it supports the ecosystem by existing as a separate library?
srandon111 has joined #lisp
<no-defun-allowed>
Or on the other hand, I could say I have three projects, and none of them are disconcertingly large.
<adlai>
recently I broke apart scalpl into separate systems, because it was making http requests at compile- and load-time, so the systems for each exchange are now separate, and the linecount space is arguably also not euclidean.
srandon111 is now known as sukablyat
sukablyat is now known as facksheet
facksheet is now known as fackshiet
fackshiet is now known as fuuckshiit
nij has joined #lisp
* adlai
used the word 'gangrenous' to describe code that is actively bitrotting, by being an unchanged implementation of unstandardized protocols; e.g., reading a data feed published by a sketchy exchange
<no-defun-allowed>
To be fair, I have gone on an anti-minimalist streak, with enough abstractions and polymorphism to scare aeth at least. But it's somewhere around 30 to 100 times larger than an implementation of a more stupid protocol! That just seems wrong.
jprajzne has quit [Quit: jprajzne]
<adlai>
considering scalpl as a central library, along with half a dozen exchange implementations, gives a much better picture of the same lines' counts; and a similar split is probably possible with games and game engines
<adlai>
complexity of class and method hierarchy is a much better metric
aartaka has joined #lisp
<adlai>
what exactly are you considering as part of the "full network stack"?
<adlai>
[e.g., "upwards of firmware; both client, and server"]
hiroaki has joined #lisp
<no-defun-allowed>
I have a distributed hash table and a protocol for handling wire protocols, a distributed object system, a bytecode interpreter for reproducible computing, a server and client that glue those together, and a filesystem-backed "database" for the server.
<phoe>
in only 10k lines of code?
<no-defun-allowed>
Okay, I guess 10k is small for those then?
* adlai
raises floor to... "upwards of data layer" ?
aartaka_d has quit [Ping timeout: 272 seconds]
<phoe>
separate those projects from one another
<phoe>
on the interface layer
<phoe>
count LoC separately for each of them
<phoe>
that'll that should give you a somewhat better picture
<no-defun-allowed>
I have, I have three projects. Then I have 3,200 lines, 3,400 and 1,700.
<phoe>
that's not much, given that you have clean interface boundaries between those
<phoe>
and you likely do, knowing your programming style
<no-defun-allowed>
I hope so.
<adlai>
which is which? netfarm, cl-decentralize2, ...?
<no-defun-allowed>
My size ratio was wrong; it's closer to my implementation being 20× larger.
<no-defun-allowed>
adlai: Well, cl-decentralise2 (3200 lines) does DHT and wire protocol, Netfarm (3400 lines) does object system and bytecodes, and I have "glue code" (without a better name -- 1700 lines) which extends decentralise2 server and client to work with Netfarm.
<flip214>
I've written a snippet that counts forms (recursively) instead of lines, and takes ' and ` as single items (as they're mostly data, not logic)
<no-defun-allowed>
I may need to update that README for the next release. I've done all three of those.
<flip214>
LOC doesn't help much for things like (LET ((a 1)\n(b 2)) or long parameter lists in DEFUN and so on
<no-defun-allowed>
Yeah, I get a lot of additional lines from using long names, such as UPDATE-SYSTEM-FOR-NEW-INTERESTING-OBJECT-PREDICATE
<adlai>
the unit of mental load is the screenfull; and if your widescreen battlestation has three windows of your IDE open, then that is three screenfulls in one monitor.
<Nilby>
cl-linecount-geometer - a multi-dimensional code density mapper
<easye>
And a screenful should be 80x25 damnit.
<adlai>
both LOC and SLOC are worthless metrics when you have lots of utilities; decide to use alexandria, or anaphora, etc, and suddenly have your linecount vanishes, and the other half - has to be rewritten
<adlai>
80x25, that's what... eighty columns, twenty three rows, a docstring, and a modeline?
<Nilby>
adlai: Yes, I agree, and that proably why that package won't exist.
* easye
has a small brain.
rogersm has joined #lisp
<adlai>
Nilby: no, I disagree; the friction for that package's creation is that the topologists are busy catching up on twentieth-century technical debt; all those junk categories and complexity classes of linear algebra optimizations
hendursa1 has joined #lisp
rogersm has quit [Ping timeout: 272 seconds]
<Nilby>
adlai: hmmmm, that could be. It seems almost everyone, including me, is still mired in 20th cen. debt.
<Nilby>
tech debt that is
hendursaga has quit [Ping timeout: 240 seconds]
jprajzne has joined #lisp
frost-lab has quit [Quit: Connection closed]
<Nilby>
easye: I've been trying to hang in there for years considering terminals at 80x25, but sometimes that window just needs to be expanded. emojis and non-latin chars can bring it down closer to 40x25 too.
<Nilby>
ascii art sometimes needs a bigger canvas too
jprajzne has quit [Client Quit]
rogersm has joined #lisp
jprajzne has joined #lisp
<Nilby>
Of course the small assumtion works well coding on the phone
mrcom has quit [Quit: Leaving]
edgar-xyz has quit [Quit: Leaving]
<adlai>
the tablet's 80x25 is "one paragraph of a Paul Graham essay", because you should not be editing, nor source code, on a touchscreen
amb007 has quit [Read error: Connection reset by peer]
edgar-rft has joined #lisp
amb007 has joined #lisp
housel has quit [Ping timeout: 258 seconds]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
rgherdt has joined #lisp
marusich has quit [Quit: Leaving]
<Nilby>
Coding in the repl with good completion is not as bad as one might imagine on a tiny device. I've also been tinkering an audio only repl for a while.
olle has left #lisp [#lisp]
luni has joined #lisp
<Nilby>
but I like how PG admitted he coded much of hackernews at the repl of the live running site.
amb007 has quit [Read error: Connection reset by peer]
skapata has joined #lisp
amb007 has joined #lisp
housel has joined #lisp
<adlai>
the failure mode of repl+production is harmless, you just ask someone to go reboot the server; failure more of touchscreen IDE is that suddenly you start counting how many pixels your code is, and your unit of measurement is nonlinear and called the fingersmudge
* Nilby
... addding fingersmudge to the units database
<adlai>
Nilby: if I understood correctly, that you have actually developed code in a repl from a touchscreen: you use the system keyboard, or something smarter that the IDE provides?
<adlai>
fingersmudge has a biometrically precise definition, it's just one quantum of uncertainty in a police fingerprint database
<adlai>
in square arrangement, the fingersmudge is approximately equal to the area of a cell in minesweeper.
luni has left #lisp [#lisp]
<Nilby>
Yes. I used the stupid on screen keyboard. sbcl with my custom shell/repl running on a linux phone.
<Nilby>
I can see you would quickly be assigned keeper of units in my imaginary kingdom. As long as it's non-cheating minesweeper based units.
ljavorsk has quit [Ping timeout: 240 seconds]
villanella has quit [Ping timeout: 240 seconds]
<Nilby>
but the thing i'm loathe to admit, is that it made me want to make "vi" bindings, since emacs chords are a bit much for smudge based input.
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
atomik has quit [Killed (adams.freenode.net (Nickname regained by services))]
Guest6090 has joined #lisp
<flip214>
Did somebody already extend prometheus.cl to give HT request latencies as well? I just added the thread count and am wondering whether I'm the first to work on that
rogersm_ has joined #lisp
wxie has quit [Ping timeout: 272 seconds]
rogersm_ has quit [Ping timeout: 240 seconds]
jprajzne has quit [Quit: jprajzne]
quadrassel4321 has joined #lisp
quadrassel4321 has quit [Quit: Leaving]
srandon111 has joined #lisp
srandon111 is now known as fuukshiit
orivej has joined #lisp
fuuckshiit has quit [Ping timeout: 246 seconds]
nostoi has quit [Quit: Verlassend]
* adlai
mumbles something about editor mode entropy flux interacting badly with translucent capacitors
<fuukshiit>
adlai, what are youo mumbling ?
<adlai>
a response to something that was written just before you joined, about editing lisp code using a touchscreen peripheral instead of a separate keyboard
<fuukshiit>
adlai, damn don't use touch screen just use a keyboard
<adlai>
once srandon111's connection stabilises, maybe I can remember what parts of the idea were signal and what parts were noise
<fuukshiit>
adlai, what do you mean?
<adlai>
it probably boils down to "modal editors oughtta waste at least one highly-visible pixel on the mode indicator"
<adlai>
fuukshiit was once known as srandon111, and is now known as fuukshiit, and I have internat enough for 2020.
adlai has left #lisp ["the channel is logged, I don't need to lurk."]
<fuukshiit>
adlai, please don't use an offensive language
jprajzne has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 264 seconds]
madage has joined #lisp
aartaka has joined #lisp
Blukunfando has quit [Ping timeout: 260 seconds]
aartaka_d has quit [Ping timeout: 256 seconds]
jprajzne has quit [Quit: jprajzne]
rogersm_ has joined #lisp
jprajzne has joined #lisp
aartaka_d has joined #lisp
fuukshiit is now known as the_emeritous_ni
the_emeritous_ni is now known as the_doctor_night
aartaka has quit [Ping timeout: 260 seconds]
the_doctor_night is now known as doc_nightmare
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
rogersm_ has quit [Ping timeout: 264 seconds]
doc_nightmare has quit [Quit: leaving]
<jackdaniel>
oni-on-ion: ?
jello_pudding has quit [Ping timeout: 272 seconds]
gaqwas has quit [Remote host closed the connection]
srandon111 has joined #lisp
<oni-on-ion>
jackdaniel, it was about your browser, hmm
jello_pudding has joined #lisp
imode has quit [Ping timeout: 260 seconds]
<jackdaniel>
I don't remember working on any browser
<jackdaniel>
I've built firefox once, but it was because I was using gentoo :)
<jackdaniel>
you probably mean a person with a nick with the same number of letters and starting with "j" (quite misleading coincidence): jmercouris
rgherdt_ has joined #lisp
toorevitimirp has joined #lisp
<oni-on-ion>
i am very emberassed
srandon111 has quit [Quit: leaving]
jprajzne has quit [Quit: jprajzne]
surabax has joined #lisp
<oni-on-ion>
it was not anything important. but i sincerely apologise for mistaking you ! dont think i have dyslexia but my brain sorts words with first letter. thank you for clarifying
<jackdaniel>
(fun fact: our irc passwords also start with the same letter and have the same number of letters!)
jeosol has quit [Remote host closed the connection]
rgherdt has quit [Ping timeout: 256 seconds]
<jackdaniel>
no worries, I will bear it
<oni-on-ion>
=)
hugh_marera has quit [Quit: Ping timeout (120 seconds)]
nij has joined #lisp
jprajzne has joined #lisp
<nij>
I have a function 'f that works as (f x y z). But now I have a list (list x y z). How would I pass the list to f?
<minion>
nij, memo from adlai: earlier someone pointed you at chanl, for writing parallelized code; you should be warned that it is unsuitable for production use (there are a few race conditions, that should be detected by test failures)
<nij>
Actuall what I want is (concatenate 'string "a" "b"), but I only have (list "a" "b")
<minion>
nij, memo from pjb: As I told you, don't leave early, people may be long to answer.
<jackdaniel>
youtube asks me to give my consent for some really long terms of service (and I don't have time to read it) - I can't watch it then, sorry
<flip214>
nij: (FORMAT NIL "~{~a~}" (list "a" "b"))
<nij>
But since there's no currying, I cannot (apply #'(concatenate 'string) '("a" "b"))
<minion>
nij, memo from pjb: Sometimes, it will take them a few seconds to type their answer!
<flip214>
nij: ALEXANDRIA provides CURRY and RCURRY
<jackdaniel>
nij: the library alexandria has functions curry and rcurry (writing your own is also trivial)
<nij>
flip214: yeah.. that's what I tried to avoid. The format syntax is not clear.
<nij>
or i can just add a comment say what it does
<edgar-rft>
nij: what's with (apply #'concatenate 'string (list "a" "b")) ?
<nij>
! haven't tried
<nij>
OHHHHHHH!
<nij>
I did not know you can use 'apply like this.
<jackdaniel>
apply treats the first argument as a function and the last one as a list, everything inbetween is treated as a single argument
<nij>
no.. cuz this doesn't work: (defun testing (a b c) (+ a b c)) (apply #'testing 1 2 '(2 3))
<jackdaniel>
you pass four arguments to testing there
<nij>
Oh ofc.
<jackdaniel>
and the function accepts three
<nij>
That's much better. I won't use ~a{~a~} anymore.
<nij>
(apply #'concatenate 'string (list "a" "b")) is much clearer, and it's a one-liner!
rogersm_ has joined #lisp
<jackdaniel>
what unclear do you find in (format t "~x~f~1234,2314sd,dsf~{fasd~[~{~a~}~]~}~%" args #'format-function 'string "xxx") ; hm?
<nij>
LOL is it a joke? Or are you serious?
<nij>
nothing is clear!
Stanley00 has quit [Remote host closed the connection]
<flip214>
nij: please be aware that the maximum argument count limit applies to apply!
rogersm_ has quit [Ping timeout: 256 seconds]
random-nick has joined #lisp
jprajzne has quit [Quit: jprajzne]
<loke[m]>
nij: Yes, flip is right. Your APPLY solution is not great. You can, however, do the following: (reduce (lambda (a b) (concatenate 'string a b)) '("foo" "bar" "test"))
aartaka has joined #lisp
<loke[m]>
Another solution: (with-output-to-string (*standard-output*) (mapc #'princ '("foo" "bar" "test")))
mrios222 has joined #lisp
harlchen has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
<nij>
@@ I don't understand the comment.. coul you please elaborate? Why isn't apply good?
<mrios222>
Hi, if I want to use SQL in a program, what is the best library to choose? My first guess is clqsl, but the links to the documentation and tutorials are dead. Any recommendations?
vegansbane6 has joined #lisp
aartaka has quit [Ping timeout: 258 seconds]
<nij>
Also, I dunno why but suddenly 'SLY' starts taking over 'SLIME'.. I like SLIME more.. what could have happened? SLY elision of strings is quite annoying..
<flip214>
there's an (implementation-specific) limit to how many arguments a function call may have -- and that also applies to APPLY
a0 has quit [Ping timeout: 240 seconds]
<flip214>
so if your list contains 1M strings (most of them could even be empty, ""), the APPLY call might fail with an error
<nij>
OH I see :O!!!
iskander has quit [Quit: bye]
iskander has joined #lisp
jprajzne has joined #lisp
Codaraxis_ has quit [Read error: Connection reset by peer]
CookE[] has quit [Quit: Leaving]
hugh_marera has joined #lisp
<Xach>
nij: you can (apply 'concatenate 'string '("a" "b"))
<Xach>
oh man, i'm way behind.
<jackdaniel>
:-)
* Xach
must keep an eye on his scroll bar next time
<jackdaniel>
it would be better if you have had started: you can't apply to the operator if ^_^
<Xach>
mrios222: i use postmodern+postgresql
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
<mrios222>
Xach: thanks, I will do that.
jprajzne has quit [Client Quit]
<Nilby>
(format t "~@:(~s~) is~:[n't~;~] ~c ~(~s~) ~(~s~)~v,,,va~%" (car -) t #\u61 (cadr (pathname-directory #p"/*/")) (car '#'_) 8 #\! #\!)
<oni-on-ion>
=/
amb007 has quit [Ping timeout: 256 seconds]
Bike has joined #lisp
amb007 has joined #lisp
yitzi has joined #lisp
rogersm_ has joined #lisp
cosimone has joined #lisp
<_death>
(constantia:out "Better " (car -) " than some " (:dc (cadr (pathname-directory #p"/**/"))))
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gargaml has joined #lisp
notzmv` is now known as notzmv
notzmv has joined #lisp
notzmv has quit [Changing host]
rogersm_ has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
devon has quit [Ping timeout: 264 seconds]
amb007 has joined #lisp
<Nilby>
I know it's wrong, but I love format. YTools is some interesting reading though.
sharo has joined #lisp
<_death>
I use format often, since it's in the standard
<oni-on-ion>
surely a macro can be made to 'decide' the best format string
<_death>
indeed my OUT macro uses format that way
<_death>
although it creates some quirks that I didn't bother with.. for example (let ((n 16) (c #\0) (w 4)) (outs (:d 12345 :width w :base n :pad-char c))) works, but add a (commas t) binding and :commas commas and you get an error
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
wsinatra has joined #lisp
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
<Nilby>
_death: Your out macro certainly seems clearer, more extensible, and more constructable. I try to resist the allure of most non-standtard constructs, because I fear getting a bit too far into a remote realm, like ytools seems.
<Nilby>
Unfortunately I've probably gone too far.
<_death>
yeah, even if operator X could be useful and make code pretty, still doesn't mean that it's a good idea to now depend on its library and use it everywhere
jprajzne has joined #lisp
FreeBirdLjj has joined #lisp
jw4 has quit [Quit: tot siens]
jw4 has joined #lisp
cross has joined #lisp
jprajzne has quit [Quit: jprajzne]
FreeBirdLjj has quit [Ping timeout: 256 seconds]
sharo has quit [Quit: rcirc on GNU Emacs 27.1]
rgherdt_ has quit [Quit: Leaving]
rgherdt has joined #lisp
jprajzne has joined #lisp
freedddd has joined #lisp
<freedddd>
Hi. I'm trying to create a function which creates a subclass that overrides all ':allocation :class' slots of the superclass (the reason is that there will be further subclasses of this subclass that share their allocation of these slots). Is there some way to do this without re-writing all the slot definitions?
<freedddd>
In CL btw
Stanley00 has joined #lisp
nij has joined #lisp
notzmv` has joined #lisp
<nij>
How to format '("a" "b" "c") to "a\nb\nc"? I used (format nil "~{~%~a~}" lst) but got "\n\na\nb\nc".. and cannot find the working variant.
<_death>
"~{~A~^~%~}"
<phoe>
(format nil "~{~A~^\\n~}" '("a" "b" "c"))
notzmv has quit [Ping timeout: 256 seconds]
EvW has joined #lisp
<phoe>
I assume you want \n and not newlines
<phoe>
if you want newlines, what _death said
Stanley00 has quit [Ping timeout: 264 seconds]
<beach>
freedddd: I am sure there is a solution using the MOP.
* Alfr_
points in the general direction of _death and phoe: "Witches!"
<_death>
as an alfr you should accept some format galdrs
<freedddd>
Thank you. I will have a look. Btw can I use MOP out of the box with CL implementations?
<beach>
You can use the compatibility library named CLOSER-MOP.
<beach>
You would have to install it using Quicklisp.
<beach>
Otherwise, most major Common Lisp implementations are supported.
<freedddd>
Thanks. I want my application to be usable on some different implementations such as SBCL, CCL, ECL
<beach>
Yes, they should all be supported.
<freedddd>
Is it hard to use basics of MOP without much study, e.g. reading AMOP? Already a rookie with CL
<beach>
You could use that metamodular site. It is based on chapters 5 and 6 of the AMOP.
<beach>
But it is better organized with links and such.
<beach>
And you can come here and ask.
<nij>
_death, phoe thanks :D
treflip has quit [Quit: WeeChat 2.6]
<freedddd>
Thanks. Will give it a try and reevaluate my approach if it turns out to be too much
<beach>
Sounds good. Good luck!
<Nilby>
Every time I thought I should use :allocation :class slots, it turned out I didn't really want that. It happened mostly when I first starting using Lisp instead of C++.
waleee-cl has joined #lisp
<beach>
Yes, it is often better to just define a method.
<freedddd>
Yeah I'm not quite sure myself. I'm trying to create "views" which contain references to underlying data structures based on certain specification (e.g. "a b c" points to structures a, b and c, while "a d" points to structures a and d). The idea is that several subclasses may share the same view (e.g. "a b c") but implement a different generic run method that acts differently.
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
<freedddd>
Now that you're mentioning it, I could instead have a single class and several differently named methods instead (rather than the generic run method). Should be easier to implement..
jprajzne has quit [Client Quit]
nij has quit [Ping timeout: 260 seconds]
jprajzne has joined #lisp
rumbler31 has joined #lisp
<Nilby>
Also keep in mind that a generic run method can specialize on various classes. (run a b c) (run a x y) (run b c d) can all be totally different methods, or not.
toorevitimirp has quit [Remote host closed the connection]
<Nilby>
And even call and combine eachother in different ways.
Necktwi has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Ping timeout: 256 seconds]
<freedddd>
I might have explained it a bit poorly. Imagine a, b, c, etc. are just arrays with values belonging to some "entity" defined by an ID. Then I want some class that acts on values of all common entities (defined by IDs) across several such arrays. That's where the idea of a view comes in, such that I don't have to rediscover and duplicately store which entities and values each class should operate on. However the logic in the run method
<freedddd>
may operate differently (but should only take the class instance as an argument in the case I was planning on).
<freedddd>
Trying to implement a dreaded entity-component system for a simple game engine
<jackdaniel>
isn't it that you want presentations in your system?
<freedddd>
jackdaniel: I'm not sure what you mean by presentations
<jackdaniel>
a presentation is an object, that associates arbitrary object with a presentation type (of course the object must be presentation-typep to said presentation type)
<jackdaniel>
it is a concept embraced by clim, but explained earlier
<jackdaniel>
give me a second, I'll look for a link
<freedddd>
Sounds about right
<Nilby>
Yes. The idea of presentations is very cool.
<jackdaniel>
CLIM incorporates presentations as one of its core abstractions
<freedddd>
The idea was: Combination of component types (e.g. "a b c") -> view with shared storage -> implement subclass which defines the generic run method to act on entities which have component types a, b and c
jprajzne has joined #lisp
<loke[m]>
jackdaniel: eugene cicarelli. Why does that name ring a bell?
<aeth>
either much better than just mindlessly repeating "foo"
noobineer has quit [Read error: Connection reset by peer]
rogersm_ has joined #lisp
gareppa has joined #lisp
<entre-parenteses>
O_O
<entre-parenteses>
That's the English language for you, I guess...
<aeth>
that's recursion
<entre-parenteses>
Ah, interesting point! I hadn't thought of it in those terms.
<aeth>
sentences like those exists for the same reason that if you balance the parentheses at the end, this is going to be valid, no matter how long it is: (+ 1 2 (+ 3 (+ 4 (+ 5 6 7 (+ 8 (+ 9 (+ 10 ...
gareppa has quit [Remote host closed the connection]
noobineer has joined #lisp
rogersm_ has quit [Ping timeout: 256 seconds]
<entre-parenteses>
Well that makes more sense. I guess I never thought of natural language from a mathematical perspective. Thanks for helping me expand my mind. :)
<aeth>
This is #lisp so we usually are here because we want to avoid complicated grammars. :-)
akoana has joined #lisp
jprajzne has quit [Quit: jprajzne]
X-Scale has quit [Ping timeout: 260 seconds]
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
<pyc>
hey sjl. would you please share your Vim + Vlime setup again? do you have the startup script or ~/.vimrc shared somewhere?
noobineer has quit [Read error: Connection reset by peer]
jprajzne has joined #lisp
jeosol has joined #lisp
Steeve has joined #lisp
EvW has joined #lisp
miasuji has quit [Ping timeout: 260 seconds]
andreyorst has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
<freedddd>
How would you get all keys of an alist? loop and collect?
<scymtym>
(map 'list #'car alist) is one way
<jackdaniel>
(mapcar #'car car) ; if your list is named car :)
<sjl>
some of this is definitely outdated, e.g. I use vlime's disassemble key instead of schlepping a (disassemble ...) form to the debugger. I should probably clean it up at some point.
EvW has quit [Ping timeout: 260 seconds]
jprajzne has quit [Quit: jprajzne]
EvW1 has quit [Ping timeout: 258 seconds]
Inline has joined #lisp
<pyc>
sjl: wow! that's a lot of setup work in .vimrc. so if I understand it right, you don't use \rr to connect Vlime to Swank.
jprajzne has joined #lisp
EvW has joined #lisp
<sjl>
That's correct, I don't use Vlime to start up the Lisp process, I do it myself (via sbcl-vlime, usually but not always running inside a Neovim terminal buffer).
<sjl>
The whole start-a-lisp-process-from-within Vlime has always felt too magic to me. I like managing the Lisp process myself and then just telling Vlime to connect to it.
<pyc>
sjl: Is NeoRepl something you have defined or is it defined by NeoVim?
<pyc>
sjl: makes a lot of sense now. thanks for sharing
<sjl>
The only thing I use it for on the Lisp side is sending `(ql:quickload ...)` forms to the REPL. I probably don't even need that TBH, I could probably do that through Vlime now that I think about it.