lucasb has quit [Quit: Connection closed for inactivity]
cosimone has quit [Quit: WeeChat 2.5]
parab has quit [Read error: Connection reset by peer]
parab has joined #lisp
Josh_2 has quit [Remote host closed the connection]
nullman has joined #lisp
jgodbout has joined #lisp
Oladon has joined #lisp
Harag has quit [Ping timeout: 245 seconds]
Harag has joined #lisp
Insanity_ has quit [Quit: Connection closed for inactivity]
vms14 has quit [Quit: WeeChat 2.3]
ebrasca has quit [Remote host closed the connection]
slyrus__ has joined #lisp
semz has quit [Ping timeout: 264 seconds]
parab has left #lisp [#lisp]
slyrus_ has quit [Ping timeout: 248 seconds]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
mindthelion has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
Oladon1 has joined #lisp
Oladon has quit [Ping timeout: 258 seconds]
<LdBeth>
Good morning everyone
orivej has quit [Ping timeout: 245 seconds]
EvW has quit [Ping timeout: 250 seconds]
Mandus has quit [Ping timeout: 268 seconds]
Mandus has joined #lisp
ltriant_ has joined #lisp
ltriant has quit [Ping timeout: 272 seconds]
_whitelogger has joined #lisp
Mandus has quit [Ping timeout: 245 seconds]
Mandus has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
Bike has quit [Quit: Lost terminal]
bkhl has joined #lisp
GloriaReed has joined #lisp
Nomenclatura has quit [Quit: q]
dddddd has quit [Remote host closed the connection]
iarebatm` has joined #lisp
GloriaReed has quit [Quit: GloriaReed]
GloriaReed has joined #lisp
jgodbout has quit [Ping timeout: 248 seconds]
libertyprime has quit [Quit: leaving]
krwq has quit [Remote host closed the connection]
GloriaReed has quit [Quit: GloriaReed]
iarebatm` has quit [Ping timeout: 245 seconds]
<beach>
Good morning everyone!
Nomenclatura has joined #lisp
vms14 has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
<beach>
aeth: I have always heard good things about Amiga. I am not sure there is much to say about "datatypes" other than that it looks like someone thought about what we would call a protocol and implemented it consistently. That's good.
nowhereman has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
Mandus has quit [Ping timeout: 268 seconds]
Mandus has joined #lisp
gravicappa has joined #lisp
wigust- has joined #lisp
Harag has quit [Read error: Connection reset by peer]
wigust has quit [Ping timeout: 245 seconds]
Harag1 has joined #lisp
Harag1 is now known as Harag
techquila has joined #lisp
theblacksquid has quit [Remote host closed the connection]
spm_ has quit [Remote host closed the connection]
GloriaReed has joined #lisp
permagreen has joined #lisp
vms14 has quit [Quit: WeeChat 2.3]
Kevslinger has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
mindthelion has joined #lisp
techquila has quit [Remote host closed the connection]
ltriant_ has quit [Quit: leaving]
orivej has joined #lisp
sauvin has joined #lisp
GloriaReed has quit [Quit: GloriaReed]
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
vlatkoB has joined #lisp
vlatkoB_ has joined #lisp
zulu-inuoe__ has joined #lisp
vlatkoB has quit [Ping timeout: 245 seconds]
ravenous_ has joined #lisp
zulu-inuoe_ has quit [Ping timeout: 246 seconds]
schweers has joined #lisp
ggole has joined #lisp
Mandus has quit [Ping timeout: 244 seconds]
Mandus has joined #lisp
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
<zmyrgel>
its odd as make-pathname call seems to create proper pathname for the sub directory
<zmyrgel>
but then the directory-files seems to list files at 'alerts' directory for some reason
<zmyrgel>
I'd like to have the list-customer-alerts function return list of *.net files in customers directory
<Lycurgus>
pathnames is a common snag
<Lycurgus>
unclear from the pastebin what platform
<zmyrgel>
shouldn't pathnames solve the platform issue
<Lycurgus>
i.e. what FS
<zmyrgel>
linux at the moment
<Lycurgus>
no it's highly platform specific, if uiop or whatever were super robust maybe
<_death>
zmyrgel: if it's a subdirectory, you should (merge-pathnames (make-pathname :directory (list :relative customer)) *alert-dir*)
<zmyrgel>
_death: and it seems to work, thanks
dale_ has joined #lisp
dale_ is now known as dale
jprajzne has quit [Remote host closed the connection]
a7f4 has quit [Ping timeout: 258 seconds]
random-nickname has quit [Remote host closed the connection]
Oladon_work has joined #lisp
<schweers>
I have not tried this, but I think using :name customer is a mistake. This means that you have a file with the name of the value of CUSTOMER, instead of appending said value to the directory part of the path.
<schweers>
zmyrgel: ^
Oladon_work has quit [Remote host closed the connection]
random-nick has joined #lisp
gko has joined #lisp
MrMc has joined #lisp
igemnace has joined #lisp
sonologico has joined #lisp
Oladon_work has joined #lisp
borracciaBlu has joined #lisp
borracciaBlu has quit [Ping timeout: 244 seconds]
<zmyrgel>
is osicat still the best option to read file modified time?
Ven`` has joined #lisp
ravenous_ has quit [Read error: Connection reset by peer]
ravenous_ has joined #lisp
Necktwi_ has joined #lisp
cosimone has joined #lisp
bendersteed has joined #lisp
<ebrasca>
Hi
<beach>
Hello ebrasca.
bjorkintosh has quit [Quit: Leaving]
bjorkintosh has joined #lisp
cosimone has quit [Quit: WeeChat 2.5]
random-nick has quit [Ping timeout: 245 seconds]
cosimone has joined #lisp
EvW has quit [Ping timeout: 250 seconds]
<ebrasca>
It is hard to think what to write next.
FreeBirdLjj has joined #lisp
ravenou__ has joined #lisp
random-nick has joined #lisp
random-nick has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 258 seconds]
ravenous_ has quit [Ping timeout: 264 seconds]
<ck_>
"all you have to do is push the right buttons in the right order"
smazga has quit [Ping timeout: 246 seconds]
ravenou__ has quit [Read error: Connection reset by peer]
Necktwi_ has quit [Ping timeout: 268 seconds]
ravenous_ has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
koenig has joined #lisp
random-nick has joined #lisp
Lycurgus has quit [Quit: Exeunt]
manualcrank has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Necktwi_ has joined #lisp
borracciaBlu has joined #lisp
smazga has joined #lisp
vsync is now known as ShamelessMendica
ShamelessMendica is now known as ShamefulMendican
ShamefulMendican is now known as ShamedMendicant
ShamedMendicant is now known as vsync
borracciaBlu has quit [Ping timeout: 272 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
DGASAU has quit [Ping timeout: 272 seconds]
EvW has joined #lisp
sonologico has quit [Ping timeout: 245 seconds]
saravia has joined #lisp
cosimone1 has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
Ven`` has joined #lisp
EvW has quit [Ping timeout: 250 seconds]
cl-arthur has joined #lisp
bchar has left #lisp [#lisp]
Necktwi_ has quit [Ping timeout: 272 seconds]
cosimone1 has quit [Quit: WeeChat 2.5]
Necktwi_ has joined #lisp
maxxcan has joined #lisp
cosimone has joined #lisp
pnp has joined #lisp
xivh has joined #lisp
<xivh>
Can anyone help with a slime mode problem?
<Josh_2>
Whats the problem?
<Oladon_work>
No one. No one at all.
<xivh>
After I load from a file, doing cc cc on a function gives me a compile
<xivh>
message but doesn't actually rewrite the function.
ggole has quit [Quit: Leaving]
<xivh>
So after I run my unit tests, I have to restart slime to keep working.
<ebrasca>
xivh: It is C-c C-c ...
<xivh>
Yes, it works initially.
<ebrasca>
xivh: is it defconstant , defvar or someting similar?
<Oladon_work>
xivh: How are you determining that it "doesn't actually rewrite the function"? Are you sure you're not dealing with closures?
maxxcan has quit [Remote host closed the connection]
<xivh>
I have a defun in a file, I can do C-c C-c to recompile as I edit it. Then I load a file with unit tests, and after it runs, C-c C-c says it is compiling but the function will not change unless I restart slime.
buffergn0me has joined #lisp
<xivh>
I know it isn't rewriting the function because if I start slime and run the unit tests, then do C-c C-c and try to use the function, it says it hasn't been defined.
borracciaBlu has joined #lisp
random-nick has quit [Ping timeout: 272 seconds]
<Oladon_work>
That doesn't sound like a slime issue. Have you tried the same thing in your basic REPL?
maxxcan has joined #lisp
borracciaBlu has quit [Ping timeout: 248 seconds]
nanozz has quit [Ping timeout: 248 seconds]
<xivh>
In sbcl I can't use the function at all.
<xivh>
Never mind, I can if I enter the package.
sauvin has quit [Ping timeout: 272 seconds]
pnp has left #lisp [#lisp]
smazga has quit [Ping timeout: 246 seconds]
bendersteed has quit [Remote host closed the connection]
zotan has quit [Ping timeout: 264 seconds]
puchacz has joined #lisp
zotan has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
parab has quit [Quit: parab]
parab has joined #lisp
zmyrgel has quit [Remote host closed the connection]
cyberyl has joined #lisp
puchacz has quit [Quit: Konversation terminated!]
Tristam has quit [Ping timeout: 272 seconds]
GloriaReed has joined #lisp
xivh has quit [Ping timeout: 272 seconds]
random-nick has joined #lisp
Tristam has joined #lisp
parab has quit [Ping timeout: 248 seconds]
superkumasan has quit [Ping timeout: 248 seconds]
smazga has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
Tristam has quit [Ping timeout: 246 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
cl-arthur has quit [Remote host closed the connection]
EvW has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
niceplace has quit [Ping timeout: 246 seconds]
LiamH1 has joined #lisp
Necktwi_ has quit [Remote host closed the connection]
LiamH has quit [Ping timeout: 245 seconds]
iarebatm` has quit [Ping timeout: 245 seconds]
cosimone has quit [Ping timeout: 252 seconds]
Grauwolf has joined #lisp
Grauwolf has quit [Changing host]
Grauwolf has joined #lisp
cosimone has joined #lisp
Lycurgus has joined #lisp
GloriaReed has quit [Quit: GloriaReed]
GloriaReed has joined #lisp
GloriaReed has quit [Quit: GloriaReed]
GloriaReed has joined #lisp
gravicappa has quit [Ping timeout: 268 seconds]
maxxcan has quit [Quit: maxxcan]
borracciaBlu has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
borracciaBlu has quit [Ping timeout: 268 seconds]
ravenous_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
GloriaReed has quit [Quit: GloriaReed]
drot has quit [Ping timeout: 268 seconds]
vms14 has joined #lisp
<vms14>
I want to read some lisp code, I still being a lisp noob, do you have some suggestion to look at?
lemoinem has quit [Ping timeout: 246 seconds]
Lycurgus has quit [Quit: Exeunt]
<moldybits>
hm
lemoinem has joined #lisp
<moldybits>
quicklisp? i don't know. any project that interests you. it's not like you have to read all of it to learn something.
slyrus__ has joined #lisp
<vms14>
yeah I was going to look a cl-who and alike
<vms14>
but wanted to know if someone had a recommendation of some code that thinks it's well written or easy to understand for a beginner in order to learn
slyrus_ has quit [Ping timeout: 248 seconds]
bendersteed has joined #lisp
Insanity_ has joined #lisp
niceplace has joined #lisp
<Josh_2>
vms14: code in OO programming in common lisp by Sonya Keene is good stuff
<Josh_2>
to be fair the code in CL books is going to be good examples
<White_Flame>
PAIP is run to go through as well. The code is quite simple, but does a lot
<White_Flame>
s/run/fun/
<Josh_2>
The middle is all AI stuff and I don't have a clue what is going on
<Josh_2>
not sure if I would call it fun ʕ·͡ᴥ·ʔ
<bendersteed>
give it some time it makes sense after a while
<vms14>
Josh_2: I'm more interested atm to convert oop code to fp, but no idea about how, I know closures are the way, but that's all
<Josh_2>
Why would you need to do that?
arduo has joined #lisp
<Josh_2>
CL is very good at OO
<Josh_2>
I'm actually trying to do the opposite right now haha
<vms14>
I guess CLOS is a bunch of closures, don't?
<White_Flame>
vms14: Let Over Lambda is all about closures
sonologico has joined #lisp
<aeth>
vms14: No, the argument is that closures are roughly equivalent
<vms14>
White_Flame: yeah I'm reading it
<White_Flame>
but I really recommend against the LoL style in practice, because it's opaque and not interactively editable
<vms14>
it shows an example about how to convert oop to fp
<White_Flame>
also, it's not functional programming. It stores the object in a closure, but is still all about mutation
<White_Flame>
Pure Function Datastructures (iirc) gets into FP data
<White_Flame>
*Functional
<Josh_2>
Why not just leave OOP as it is and then write some other stuff as functional programming
<aeth>
vms14: As far as FP goes, I think CL is best when the FP is limited to simple values, and the complicated data structures are mutable. So at the top level you SETF slots (standard-objects, structs, hash-tables, arrays, conses, whatever... you can avoid doing this for variables, though), but most of the functions from that level can be pure
<aeth>
vms14: I mean, a trivial example that seems pointless is (setf (aref foo 42) (+ x y)) ; pure function feeds into a mutable data structure
<Josh_2>
functional programming in cl seems more hassle than it is worth ¯\_(ツ)_/¯
<vms14>
both paradigms are useful
<Josh_2>
although fun
<vms14>
and for example if you need to represent a product, oop is a good way
<White_Flame>
it's good to limit a lot of your internal processing to being functional, and at the outer periphery manage your mutations. Deep internal mutations is usually where problems leading to a fp solution occur
<vms14>
would fp be a good way to represent a product, item, whatever has some data to represent, over oop?
<White_Flame>
I'm not a big fan of OOP in any case, so I'm quite biased there ;)
<White_Flame>
I much prefer data-oriented programming, instead of bolting functionality in with data
<Josh_2>
That's PAIP style?
<aeth>
vms14: If you can express it as multiple return values, then pure FP is fine in CL, but with the disadvantage of not really having any real explicit structure there. Imo.
<White_Flame>
and what do yo mean by "a product"? The result of multiplication? A function that multiplies?
<vms14>
but how fp would be more useful than oop representing data that oop can handle easily?
<pjb>
vms14: you might want to read gsharp, as a complete GUI application.
<vms14>
because oop is useful to have data organized
<White_Flame>
take the methods out of an object. Then it's a struct. There you have a FP data structure :-P
<vms14>
it's just a way to abstract data, but I want to know what could offer functional programming
<White_Flame>
vms14: I don't quite understand your questions, though
<aeth>
same
<White_Flame>
functional programming is simply passing around data, and when things change, return new data
<White_Flame>
instead of mutating the input data
<Josh_2>
yes
<White_Flame>
for isntance, vector addition would return a new vector instead of mutating one of the input vectors
<Josh_2>
very easy in CL but like, why stick to it if you don't have to :P
<aeth>
CL is more a language for writing functional languages than a functional language in itself. You have to add a lot of optimizations and tricks if you want to get efficient pure FP that you'd get for free from some language where that is its focus. Unless, of course, you can settle for multiple return values, in which case there isn't really a cost to returning (values 1 2 3) instead of (values 4 5 6).
<vms14>
pjb: I'll look ty
<aeth>
The exception imo is probably macros. Those are complicated enough without microoptimizing them when they're running at compile time anyway. Just treat lists as if they're pure in macros even though they're not and even though that means your code is going to cons more and run slower.
<White_Flame>
the problem with OOP is that you often end up with a deep, tangled web of object references behind your 1 "easy' object, such that when you call anything there are arbitrary unexpected mutations triggered down the chain, and taht affects other objects
<aeth>
(And it's not like you could use a purecons data structure in macros anyway, since you have to return conses)
<White_Flame>
plus, it can be much harder to test things in OOP because you have to have a ton of live objects instantiated, vs just a data representation
<aeth>
White_Flame: Those problems can usually be (mostly) solved by not having elaborate inheritance hierarchies, which certain GUI toolkits/frameworks love to do.
<White_Flame>
it's also good to remember that not everybody has a microoptimization fetish ;)
<vms14>
yeah sorry for my question, I need to learn to communicate what I want to say
gxt has joined #lisp
<vms14>
but basically is, how you convert an object to functional style
<aeth>
White_Flame: my point though was that in a pure FP language, ideally the microoptimizations to reduce consing are done for you, which isn't the case in libraryless CL
<White_Flame>
aeth: well, if you have cascading mutation event handlers, loggers, debugging hooks, indexes of objects, etc, the chain still gets deep even without frameworks and such
<vms14>
and if it's worth or what benefits could give
<White_Flame>
even just mudballing "normal" code, or going through basic iterative design changes can really tangle up OOP projects in a hidden, behind-the-scenes way
<aeth>
White_Flame: Events are really hard. Threading, too. And threaded events...
vms14 has quit [Quit: WeeChat 2.3]
<White_Flame>
threading is easy. The difficulty is just a meme
vms14 has joined #lisp
<White_Flame>
just follow the rules, don't bang data willy-nilly
<aeth>
White_Flame: For most people, threading is where you want to run 8x faster on your 8 cores, but you wind up running 0.8x faster and with things no longer happening in the correct order. :-p
<aeth>
White_Flame: One of the main pitches of FP is that if everything is functional, then e.g. switching from MAP to PMAP is trivial.
<White_Flame>
yep
<aeth>
s/is functional/is pure functional/
<White_Flame>
(and yeah, "functional programming" used to mean programming with first-class function objects, hence the "pure" label now)
<dmiles>
pure means non moduifiable objects?
<White_Flame>
yep
<White_Flame>
"functional programming" basically means that nowadays, too
<White_Flame>
where "pure functional programming language" is a language that prevents you from mutating at all, while "functional programming style" can be done via design & programmer discipline in any language
<aeth>
If CL (or an implementation) let you label a function "pure" (some languages let you do that) then (afaik) you wouldn't be allowed to SETF/SETQ in it or call functions that indirectly SETF/SETQ
<White_Flame>
see also C++ const propagation
<aeth>
and perhaps if it's more sophisticated you'd be able to SETF/SETQ, but only if it doesn't leave the scope, like a temporary i variable in a LOOP
<dmiles>
i am pretty impressed with c++ const .. it is pretty good covenrage
<dmiles>
if we in CL had that sost of const propagation it would be nice
<White_Flame>
it also doesn't mesh well with interactive programming
<White_Flame>
at least in CL style where it doesn't auto-recompile prior functions
<aeth>
White_Flame: A pure-declared function would work fine, you'd just have to treat it like a potentially inline function unless it was also declared notinline
<aeth>
Since implementations would probably take a lot more liberty to inline that
<vms14>
guys
<vms14>
why aren't we writing man pages for common lisp?
<White_Flame>
because man pages are a terrible interface?
<vms14>
not for me
<aeth>
White_Flame: imo the two most useful things to declare on a function that you can't yet do (afaik) would be "pure" and "tail recursive", where the latter could force TCO even at high debug and low speed, where those implementations with TCO would probably normally disable it.
<aeth>
GNU info is where it's at, right?
<vms14>
man lisp-function
<vms14>
and you have a reference of this function
<White_Flame>
vms14: you can set that up in emacs, to clhs a function name
<aeth>
vms14: If you're willing to accept info (which can run in emacs) as the superior alternative to man pages, I think someone made an info version of CLHS
<aeth>
iirc
<aeth>
I'm not 100% sure on that
<Bike>
it would make more sense to be able to mark individual calls as tail.
<vms14>
I'll try the emacs way then
<aeth>
Bike: Why not both? A tail recursive declaration makes sense if it's self tail recursive or mutually tail recursive with another function like a calling b calling a calling b. Marking individual calls as tail might make sense in other contexts.
<Bike>
because a tail call declaration covers the recursive case but not vice versa
<vms14>
slime had it from the first time
<vms14>
nice
xkapastel has joined #lisp
vms14 has quit [Quit: WeeChat 2.3]
mindCrime__ has quit [Ping timeout: 246 seconds]
Frobozz has joined #lisp
Frobozz has quit [Remote host closed the connection]
Bike has quit [Quit: Bike]
Frobozz has joined #lisp
random-nick has quit [Ping timeout: 244 seconds]
<Oladon_work>
I think I'm late to the discussion, but something which bothers me a ton is the recent trend of writing reducers "in a functional style" and copying the entire object each iteration just to add or change something.
borracciaBlu has joined #lisp
random-nick has joined #lisp
MrMc has quit [Ping timeout: 246 seconds]
<White_Flame>
Oladon_work: in an ideal world, with a Sufficiently Advanced Compiler™, that still could be optimized away
<White_Flame>
but yeah, when it's explicit, and its transient use like that, it might just be a needless big performance hit
<Oladon_work>
Oh, I wasn't talking about optimization, actually — my comment was while I was reading up and people were talking about mutability as if that's what functional programming is All About
<Oladon_work>
Yeah
<Oladon_work>
For me it's more the complexity that it adds... for no gain except being able to say "it's Functional!"
<Oladon_work>
I see it most often in JS: foo.reduce((item, result) => { return [...result, [foo.name]: transform(foo)] })
<Oladon_work>
Stuff like that
<White_Flame>
I can't even
<Oladon_work>
Congratulations, you've avoided mutating "result", which exists only within your reduce operation (which should really be a map operation anyway, but...)
<pjb>
You could build functionaly a function that creates a single new object.
borracciaBlu has quit [Ping timeout: 246 seconds]
<White_Flame>
if an object exposes operations that are pure FP, then that's fine, just use them even when a mutation would be faster, because the operation is there & available. But to just bolt in weirdness like that is just weird
<Oladon_work>
Yup. Yet it's extremely popular right now, because "Functional Programming is the future, and Functional Programming = immutability!"
<Oladon_work>
Btw, I'm still hiring if anyone wants to come write Lispy JS on an actually-very-cool team doing cool stuff. :)
LiamH1 has quit [Quit: Leaving.]
cosimone has quit [Quit: WeeChat 2.5]
Lycurgus has joined #lisp
arduo has quit [Ping timeout: 268 seconds]
<ebrasca>
Oladon_work: Lispy JS? Do I need to go to some place?
<Oladon_work>
ebrasca: I do not understand your question, sorry.
<housel>
Maybe he's asking if the job can be done remotely or if relocation is necessary
<Oladon_work>
Ah, that seems like a plausible interpretation. We're looking for senior developers, and the position is onsite.
<aeth>
White_Flame: In something like CL, you'd need to be able to mark data structures as pure, and for conses, since they're so simple, you'd need a separate immutable cons (icons or something). Even sufficiently smart just wouldn't work with CL's recompilation semantics and debugging ability.
Lycurgus has quit [Quit: Exeunt]
<aeth>
Oladon_work: In some languages, like Python 3, stuff like map() don't cons up a new "list" (really, vector) anymore unless you explicitly convert the result into one. I guess it's sort of like a lazy sequence. That can avoid some of the overhead of certain FP styles. In CL, you'd probably just want to refactor a MAP into a MAP-INTO, though, if possible, so there's probably less of a demand.
bendersteed has quit [Ping timeout: 246 seconds]
<aeth>
It's funny seeing a language (JS) where you afaik run it in one thread emphasizing immutability so much, though, since the main initial pitch of languages like Clojure or Haskell 10 years ago is that immutable data structures are easier to work with in threads.
lavaflow has joined #lisp
khisanth_ has quit [Ping timeout: 244 seconds]
<ebrasca>
Oladon_work: Thanks!
<Oladon_work>
aeth: Heh, yeah
iarebatm` has joined #lisp
smazga has quit [Quit: leaving]
cyberyl has quit [Remote host closed the connection]
dddddd has quit [Ping timeout: 246 seconds]
khisanth_ has joined #lisp
GloriaReed has joined #lisp
t58 has quit [Quit: Leaving]
GloriaReed has quit [Client Quit]
GloriaReed has joined #lisp
ltriant has joined #lisp
Lycurgus has joined #lisp
Oladon_work has quit [Ping timeout: 260 seconds]
Tristam has joined #lisp
Lycurgus has quit [Quit: Exeunt]
Kevslinger has joined #lisp
sonologico has quit [Ping timeout: 258 seconds]
semz has quit [Quit: Leaving]
GloriaReed has quit [Ping timeout: 246 seconds]
random-nick has quit [Ping timeout: 246 seconds]
Bike has joined #lisp
sonologico has joined #lisp
Jesin has quit [Quit: Leaving]
Frobozz has quit [Ping timeout: 245 seconds]
Jesin has joined #lisp
borracciaBlu has joined #lisp
borracciaBlu has quit [Ping timeout: 245 seconds]
amerlyq has quit [Quit: amerlyq]
saravia has quit [Remote host closed the connection]