morganw has quit [Remote host closed the connection]
Alfr has joined #commonlisp
molson has quit [Remote host closed the connection]
<pjb>
On the other hand, if you know some Javascript, that's prototype based too, so KR should go easy for you.
molson has joined #commonlisp
<hayley>
pjb: No need to be so Self-less.
<aeth>
You don't need to pay people to code CL, though.
<aeth>
You just come into #commonlisp and tell them "Common Lisp is completely incapable of doing %A" task
<aeth>
Then someone will do it for free just to prove you wrong.
Brucio-61 has quit [Ping timeout: 265 seconds]
<jeosol>
aeth: that's funny. Reverse psycology I guess
thuna` has quit [Ping timeout: 268 seconds]
thuna` has joined #commonlisp
thuna` has quit [Remote host closed the connection]
thuna` has joined #commonlisp
gateway2000 has joined #commonlisp
kuao has quit [Quit: Connection closed for inactivity]
razetime has joined #commonlisp
epony has joined #commonlisp
waleee has quit [Ping timeout: 252 seconds]
jeosol has quit [Quit: Client closed]
Brucio-61 has joined #commonlisp
karlosz has quit [Quit: karlosz]
tyson2 has quit [Remote host closed the connection]
razetime has quit [Ping timeout: 265 seconds]
razetime has joined #commonlisp
dre has quit [Ping timeout: 268 seconds]
causal has joined #commonlisp
SR-71 has joined #commonlisp
jeosol has joined #commonlisp
hashfunc has joined #commonlisp
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
dre has joined #commonlisp
dre has quit [Ping timeout: 268 seconds]
thuna` has quit [Remote host closed the connection]
igemnace has joined #commonlisp
igemnace has quit [Remote host closed the connection]
szkl has quit [Quit: Connection closed for inactivity]
azimut has quit [Ping timeout: 258 seconds]
attila_lendvai has joined #commonlisp
aartaka has joined #commonlisp
nyx_land has quit [Remote host closed the connection]
nyx_land has joined #commonlisp
fourier has quit [Remote host closed the connection]
<Shinmera>
aeth: if only that were actually true
<hayley>
Well. I had another stab at hash tables because I was so annoyed watching a presentation by someone at AWS, who boasted having such scalability and performance, while running the benchmark in a way that it'd only measure context switching speed.
<hayley>
As it happens, it's not very hard at all to service 100k messages a second, from memory and on the same machine.
taiju` has joined #commonlisp
taiju` is now known as taiju
SR-71 has quit [Remote host closed the connection]
attila_lendvai has quit [Ping timeout: 260 seconds]
_cymew_ has joined #commonlisp
ttree has quit [Ping timeout: 252 seconds]
<AadVersteden[m]>
NotThatRPG: It suffers from Greenspun's tenth rule of programming. Since we've added inheritance, working with MOP would have made things cleaner. The code suffers from adding features over cleanup anyhow (that's no me not reserving time). But it is widely used and has pushed forward a lot of projects.
<AadVersteden[m]>
So happy with Common Lisp at this front that I'm contemplating to rewrite the authorization layer in Common Lisp but somewhat high thread creation cost, less threading failsafes and (realistically the major) time constraints are holding me back.
<AadVersteden[m]>
jcowan: Can you check out redpencil.io's website and shoot us an email at meettheteam@redpencil.io? If you mention Common Lisp or #lisp or anything related to me it will certainly be treated. Any references that show you've done something or CV is greatly appreciated but don't spend your life making that perfect. Timezone/country is interesting to know, BE (where we're based) is a great plus but it's a tiny country.
<AadVersteden[m]>
kakuhen: We hire juniors just as much. I only know of Belgium, but I know there are (or were) opportunities there. We don't do that much lisp, possibly because there aren't that many that know the language. Our lingua franca is JavaScript. I would have found that a turn-off when I was looking for a job. Replace javascript with java and I didn't accept a job because of that when I was young.
<AadVersteden[m]>
*no-defun-allowed*: I think that was a switching point for me. We had to use a map-reduce system at university. I asked if I could implement my own map-reduce in CL rather than use Hadoop. Without all of the overhead, the lisp variant running on a single node was about as fast as a 10-node Hadoop system.
<hayley>
I came up with a shitty algorithm that scaled right up to 24 threads just fine, but it was still no faster than a serial algorithm.
<AadVersteden[m]>
I have later encountered sensible spaces for distributed map-reduce setups (we built the Big Data Europe setup which used mu-cl-resources as I think of it now). Most companies that have "Big Data" are better served by 512Gb-2Tb ram on a single node.
<AadVersteden[m]>
*no-defun-allowed*: Oh yeah! That too. Threading becomes more and more important, but I find we are at the assembly level of threading for most cases still: we're doing it manually based on limited constructs (say that lparallel compares to C in that case).
<AadVersteden[m]>
As a confirmation, that PDF is the best to read?
<hayley>
(I did get eye-twitches when being told Google invented map-reduce. Maybe, but map and reduce are olde, and I doubt their relevancy to parallelism and work partitioning are novel. The latter certainly not - there was a paper on automatically partitioning storage used by APL programs to minimize paging.)
<hayley>
I believe so.
<AadVersteden[m]>
Credit is not always given where credit is due. But I do see it as an important step to have a community of developers hunt after a single paradigm so at least there's a common nomenclature amongst developers that don't try to discover as much by themselves.
<kakuhen>
Aad Versteden: It's good to hear junior positions are being considered. Unfortunately, I am not close to Belgium. When I was looking for Clojure jobs, most EU-based companies wanted applicants to be within 2 hours of Central European Time. Presumably there is a similar requirement at your company?
<beach>
kakuhen: What prevents you from moving?
<hayley>
Sure. It came off like hyping the methodology, though, as they mention "Look, Google does it! So does Amazon!"
<hayley>
The irony when all but one of the programs we wrote in that assignment used shared memory, making using them in a distributed setting intractable.
<kakuhen>
beach: Cost, for starters, and figuring out any visa applications. The language is another thing. I am okay with English and Japanese. If I recall correctly, Beglium has two(?) official languages, neither of which I have ever tried learning.
<kakuhen>
With that said, this is probably off-topic, so let's conclude here.
<beach>
kakuhen: I think those are minor problems. And Belgium is probably a good place to live. I am sure you could use English initially.
<hayley>
Aad Versteden: In the case of data-parallelism/vectorisation, the status quo literally is assembly, since automatic approaches tend to be hit or miss. Arguably, say, my one-more-re-nightmare library is a domain-specific vectorising compiler (for regex). I wonder if there's an analogue for task-parallelism and threads.
attila_lendvai has joined #commonlisp
shka has joined #commonlisp
cage has joined #commonlisp
<AadVersteden[m]>
kakuhen: We consider everything, really. We know it's much easier when people are in the same time zone but we've been working with people elsewhere too. We have some people in Spain for instance, and we support our customers with people too, some of which are on the outskirts of the European continent. We're remote oriented anyhow.
<hayley>
I guess, if the task is that easy to auto-vectorise, automatically introducing threads can't be hard. I could think of some uses for parallelism, but they'd mess with the cost model of the user, who might expect one call to my library to only use one thread at a time.
<hayley>
Apologies for my (actually unrelated) cynicism; is that remote-oriented like international tours of rock bands are international? Last time I applied for a remote job, I was too remote in Australia, and their workers were in the US and Europe.
<AadVersteden[m]>
*no-defun-allowed*: Sorry. I very much push against the hegemony of Big Tech. It's not always plausible and we're certainly not perfect.
<hayley>
Nothing to apologise for, unless I've misread something.
<AadVersteden[m]>
*no-defun-allowed*: is one-more-re-nightmare yours? it's one of the things that was important for the authorization rewrite. Really interesting but made me realize we need to split up interpretation internally (too large character groups that are not used often).
<hayley>
It is, yes.
<hayley>
Right, I don't support character groups like [:alpha:] yet.
<AadVersteden[m]>
Ah, thank you for replying to the GitHub issues then XD
<AadVersteden[m]>
Not the problem. We have groups like `[10000-EFFFF]`
<kakuhen>
hayley: I think the remote policies differ wildly on the company; the place I'm at right now has people mostly in the east coast of the US and Canada, but there's also people in Taiwan, some countries in South America, and Israel
<hayley>
(Design paralysis, I admit, I don't know how I want to process those - I need to implement union, complement and intersection on my character sets, and I'm not sure how clever I need to be around such character sets.)
<hayley>
Oh, that kind of set should be fine in theory, but I have no syntax for writing such a character.
<kakuhen>
I'm in the US west coast, which means a looot of meetings for me may have to be at 7am, and that's already pretty late for the east coast x.x
<hayley>
In the meeting I did have, I recalled that morning standups would be at about 4pm here, which isn't quite the morning.
<kakuhen>
...(but it could be worse... one of my friends was once researching some cognitive science topic with researchers in Germany, and meetings were at 6am pacific time)
<AadVersteden[m]>
kakuhen: west-coast us is annoying for me. I've done it, but I tend to be tired when making a phonecall to have any overlap then and it just makes things a bit harder. We have a hands-off approach so it's possible.
<AadVersteden[m]>
*no-defun-allowed*: wouldn't that set be too large to be efficient?
<AadVersteden[m]>
*no-defun-allowed*: I think I got much faster results when dropping the extra character sets.
<hayley>
(On [:alpha:] and friends, well, I wonder if I could represent such sets as formulas in disjunctive normal form or something, and have a bit vector representing if each term is allowed.)
<hayley>
OMRN compiles in terms of ranges these days. So [10000-EFFFF] shouldn't be faster or slower than [a-c] I believe.
<AadVersteden[m]>
Oh. It's not bit vectors anymore? I'm confused
<hayley>
I probably mentioned using bit vectors to represent [:alpha:] which is sparse and has too many ranges.
<hayley>
Early versions (before Quicklisp, maybe, I forgot) had sets of every character, more recent versions have sets of ranges. I haven't implemented anything to do with bit vectors yet.
<AadVersteden[m]>
kakuhen: that's why I don't like working with west-coast. I either have to get up too early and work that in family life or I have to call late. ... or have someone try to execute work whilst working hours they don't appreciate which leads to just as bad of an outcome.
<AadVersteden[m]>
*no-defun-allowed*: I think my biggest complaint so far is the name. It hints me that I'm working on something bad. A job that's not fun. I think it's a cool piece of tech and I like it. If we do the mu-authorization rewrite at some point, there's a good shot omrn will be in it.
<hayley>
Hey, DNF probably works great for this, come to think of it. I can have a vector mapping every character to an index representing its classes (alpha, upper, lower, etc), and then index that DNF bit vector I had alluded to, to test membership.
<AadVersteden[m]>
That'll probably yield millions of calls per day, I guess.
<AadVersteden[m]>
DNF?
<hayley>
Disjunctive normal form.
<AadVersteden[m]>
Loop over the characters in the string to define the class once?
<AadVersteden[m]>
s/class/classes/
<hayley>
I'm just thinking to myself about how to implement character classes, nothing important. I admit the name is a bit immature; it's missing one letter from the name of a song by King Crimson.
<AadVersteden[m]>
Don't know the song, am interested. SEXML isn't a mature name either. I can't complain without looking at myself too.
<hayley>
"One More Red Nightmare" with an extra #\d
<hayley>
For a brief moment, implementing character classes seemed easy, then I realised I need to also have set operations on the usual character sets and character classes. urp
<hayley>
Representing sets in disjunctive normal form is a good heuristic, but I'll need to think about how these two kinds of sets interact.
<kakuhen>
Aad Versteden: Is there an e-mail address that I can contact you with? Or is it just the meettheteam e-mail that is available?
Colere has quit [Ping timeout: 265 seconds]
Colere has joined #commonlisp
Furor has joined #commonlisp
Colere has quit [Ping timeout: 265 seconds]
<AadVersteden[m]>
*no-defun-allowed*: Read the paper. Interesting work. Results are even more extreme than I had measured.
Krystof has joined #commonlisp
hashfunc has quit [Remote host closed the connection]
dre has joined #commonlisp
Dynom_ has joined #commonlisp
Dynom_ is now known as Guest5058
dre has quit [Ping timeout: 264 seconds]
random-nick has joined #commonlisp
razetime has quit [Ping timeout: 264 seconds]
igemnace has joined #commonlisp
cage has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
karlosz has joined #commonlisp
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
VincentVega has joined #commonlisp
attila_lendvai has quit [Ping timeout: 250 seconds]
VincentVega has quit [Remote host closed the connection]
McParen has joined #commonlisp
<AadVersteden[m]>
kakuhen: I'll DM you my email address too which is hyper hard to guess, but meettheteam is a better approach as I don't always get through all of my email and meettheteam also lands where I can read it.
Furor is now known as Colere
<AadVersteden[m]>
scratch that, you try to DM me because I'm hitting some error.
orestarod has joined #commonlisp
igemnace has quit [Quit: WeeChat 3.6]
cage has joined #commonlisp
pve has joined #commonlisp
jmdaemon has quit [Ping timeout: 268 seconds]
makomo has quit [Ping timeout: 244 seconds]
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
puchacz has joined #commonlisp
selfish has joined #commonlisp
tevo has quit [Ping timeout: 265 seconds]
anticomputer has quit [Ping timeout: 258 seconds]
cosimone has joined #commonlisp
anticomputer has joined #commonlisp
thuna` has joined #commonlisp
ldb has joined #commonlisp
azimut has joined #commonlisp
razetime has joined #commonlisp
ldb has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
<mathrick>
is LET (with parallel bindings) being the default form there to achieve something otherwise difficult to do with LET*, or is it simply to give implementations more freedom to order things how they like for optimisation purposes?
* ski
. o O ( `(let ((a b) (b (+ a b))) ..a..b..)' )
igemnace has quit [Remote host closed the connection]
<jcowan>
Both or neither. Let provides access to the outer bindings, like (let ((x 0)) ... (let ((x (+ x 1)) ...)
<aeth>
So conceptually, LET is lower level than LET*
<aeth>
Implementing %let* from %let or from lambda is left as an exercise to the reader.
wheelsucker has quit [Remote host closed the connection]
<aeth>
Note that CLs can do whatever they want here if they think that they can produce faster machine code (or produce machine code faster) another way. They don't have to do it the textbook way.
wheelsucker has joined #commonlisp
_cymew_ has quit [Ping timeout: 265 seconds]
makomo has joined #commonlisp
<AadVersteden[m]>
jcowan: Got it! Humbled scrolling through it.
* jcowan
blushes
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #commonlisp
wheelsucker has quit [Remote host closed the connection]
tyson2 has quit [Remote host closed the connection]
nexalam has joined #commonlisp
aartaka has quit [Ping timeout: 265 seconds]
Guest5058 has quit [Quit: WeeChat 3.6]
Everything has quit [Quit: leaving]
tyson2 has joined #commonlisp
ttree has joined #commonlisp
tyson2` has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
tyson2` has quit [Remote host closed the connection]
wheelsucker has joined #commonlisp
cage has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
<mathrick>
aeth: right, but generally freedom to reorder things is better for producing faster code than a rigid ordering of operations. I mean, CLs can only do "whatever they want" within the realm of preserving the observable behaviour :)
contrapunctus has joined #commonlisp
<mathrick>
also, you can rewrite LET in terms of LET* as well, at the price of introducing a couple gensyms to keep the shadowed bindings around
lechner has quit [Quit: WeeChat 3.5]
lechner has joined #commonlisp
Inline has joined #commonlisp
<Josh_2>
To use an ORM or not
<Josh_2>
that is the question
<jcowan>
I can't much see the point in a dynamically typed language.
Inline has quit [Quit: Leaving]
<aeth>
mathrick: I thought reordering was more something that the CPU does, rather than the compiler
nexalam has quit [Quit: Leaving]
<mathrick>
oh, no. 90% of "GCC broke a bunch of C code because of some new optimisation" is because they did aggressive reordering based on a strict reading of the spec. And 90% of "C is actually way slower than it should be" is because it introduces many non-obvious dependencies that force the compiler to order things in a particular way and assume preceding operations' effects are visible in the following ones
nexalam has joined #commonlisp
<Bike>
mathrick: LET does parallel bindings, but the evaluation of the value forms take place serially.
<Bike>
so it won't let the compiler do any more reordering than let* would.
<mathrick>
Bike: oh, is that actually specified? Or is that a corollary of the fact that LET is defined in terms of LAMBDA, and LAMBDA evaluates its arguments in normal order?
<Bike>
it is actually specified. the second paragraph of the description
nexalam has quit [Remote host closed the connection]
<Bike>
let is not defined in terms of lambda.
<Bike>
i mean, i assume you are talking about CL rather than scheme
<aeth>
I don't think LET is defined in terms of LAMBDA in the spec, that's just a traditional equivalence.
<Bike>
so the difference between let and let* is strictly about binding visibility.
nexalam has joined #commonlisp
<aeth>
(And I don't think that R7RS specifies LET in terms of LAMBDA, I think it's just a sample implementation in the appendix. So I think neither mandates it? But this is a CL channel.)
waleee has joined #commonlisp
<mathrick>
yeah, CL
<Bike>
lisp has fairly stringent evaluation ordering. there are not many places where evaluations explicitly take place in unspecified order.
akoana has quit [Ping timeout: 265 seconds]
akoana has joined #commonlisp
shka has quit [Ping timeout: 268 seconds]
nexalam has quit [Quit: Leaving]
attila_lendvai has quit [Ping timeout: 265 seconds]
causal has quit [Quit: WeeChat 3.6]
pve has quit [Quit: leaving]
resttime has quit [Quit: resttime]
atgreen has joined #commonlisp
user_ has joined #commonlisp
wheelsucker has quit [Ping timeout: 265 seconds]
puchacz has quit [Quit: Client closed]
user_ has quit [Remote host closed the connection]
user_ has joined #commonlisp
random-nick has quit [Ping timeout: 260 seconds]
waleee has quit [Ping timeout: 268 seconds]
user_ has quit [Read error: Connection reset by peer]
wheelsucker has joined #commonlisp
resttime has joined #commonlisp
wheelsucker has quit [Remote host closed the connection]
<jcowan>
aeth: technically, no Scheme syntax is specified in terms of any other
<jcowan>
in particular, you can specify lambda in terms of case-lambda, or let* in terms of let*-values.