<White_Flame>
and the comma is just an escape from the quoting, regardless if it's an arg or not
<White_Flame>
(let ((a 3)) `(1 a ,a)) => (1 A 3)
dxtr has quit [Remote host closed the connection]
<matta_>
Yep, makes sense. I'm new to common lisp -- all my lisp experience is Emacs Lisp, where I learned only the minimum to get by. I'm not yet at the point where ,#'cons jumps out as probably wrong.
<White_Flame>
no problem. Also there's #clschool which focuses on beginner questions
<matta_>
oh, I'll check that out.
<White_Flame>
helpful if this place is busier, as such questions could get lost here
cosimone has quit [Ping timeout: 246 seconds]
tisskenzen has joined #lisp
fitzsim has joined #lisp
jpli has quit [Remote host closed the connection]
jpli has joined #lisp
jeosol has quit [Remote host closed the connection]
tisskenzen has left #lisp [#lisp]
Oladon has quit [Quit: Leaving.]
Fare has quit [Ping timeout: 260 seconds]
bendersteed has quit [Remote host closed the connection]
wsinatra has quit [Quit: WeeChat 3.0]
jpli has quit [Ping timeout: 272 seconds]
scymtym has quit [Read error: Connection reset by peer]
jpli has joined #lisp
scymtym has joined #lisp
shifty has quit [Ping timeout: 258 seconds]
Fare has joined #lisp
jpli has quit [Quit: No Ping reply in 180 seconds.]
jpli has joined #lisp
cosimone has joined #lisp
_heisig has joined #lisp
cosimone has quit [Quit: cosimone]
amerigo has quit [Quit: Connection closed for inactivity]
nij has joined #lisp
<nij>
Hello! I started writing a little cl script two days ago. It has been fun :D
<nij>
I wouldn't call it a project, but it has evolved to ~150 lines, and started to get messy..
<nij>
How would you repackage it? Should I make it a full fledge cl package?
lucasb has quit [Quit: Connection closed for inactivity]
<oni-on-ion>
hi hex. im the dude with the confusing email. sorry for the bother and thx for the response. but i may be continuing with ocaml instead, professionally. cl in sidelines
<Hexstream>
Alright, no problem.
mason has quit [Quit: leaving]
mason has joined #lisp
ldbeth`` has joined #lisp
ldbeth`` has quit [Ping timeout: 260 seconds]
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
<no-defun-allowed>
Hexstream: can I have money for CLOSOS
Oladon has quit [Read error: Connection reset by peer]
<Hexstream>
beach: By the way, there seems to have been a pretty unfortunate misunderstanding. I asked if you wanted to redirect your old CLOS MOP spec version to mine in large part to relieve you of the burden of continuing to maintain your older version, which some (presumably also yourself at the time) may now consider to be obsolete.
Oladon has joined #lisp
<Hexstream>
Let's just say I have seen some pretty hilarious misinterpretations or misrepresentations of my reasonable offer.
wxie has quit [Ping timeout: 240 seconds]
mbomba has joined #lisp
chkhd has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Fare>
jeosol, yes, the startup is Gerbil powered... see channel #gerbil-scheme for more discussions, I suppose.
<beach>
Hexstream: I see. Not important anymore.
<Hexstream>
Fare: I would need to see your list of "conditions" for you to return to Common Lisp, sometime. In fact, I would need to see that for everyone who left Common Lisp, basically.
<Fare>
Hexstream, everyone has different conditions.
<Hexstream>
beach: If it's important to you, that's enough for me. I'm not sure it should still be the "default", though.
<Fare>
I suppose that the community being unable and/or unwilling to evolve the base language is a big limitation.
<Hexstream>
Fare: Exactly, I want to help the most important ones globally.
<aeth>
Everyone has different conditions, but there's only one Common Lisp condition system.
<Fare>
CL is great, but a better language would introduce simplifications, with a backward-compatible upgrade path. And that's not going to happen.
<Fare>
The "community" is mainly made of lone wolves. I'm not going to cast stone at the other lone wolves, but that's it.
<Fare>
People with high tolerance for accumulated cruft, low tolerance to the costs of switching, low need for interaction, and often poor skills at interaction.
<Fare>
a lot of superproductive people, but with low synergy.
<Fare>
Nothing that you can help with by yourself, or anyone.
<Fare>
Bringing newbies to cl packages and pathnames and systems and case-converting symbols and high impedance mismatch to the underlying Unix or Windows OS? Why would you do that?
<Fare>
And if there are no newbies, it's the same old wolves.
<fengshaun>
is there a library which can parse a datetime string with an alternative timezone? neither local-time nor cl-date-time-parser allow me to specify an alternate timezone when parsing datetime strings
<fengshaun>
they just assume everything is in my local timezone
<fengshaun>
All times I have are in UTC, but it's not specified in the timestring
<White_Flame>
you could append the zone to the timestring before decode?
<oni-on-ion>
but to top the list of Pros: would be the community. i can get help or help others with CL a lot quicker and more often than most other "medium-popular" platforms. which are generally mailing list, web forums, in person in academic setting, or simply overpopulated.
scrungyforma has joined #lisp
<fengshaun>
edgar-rft, I already have, even manually set *default-timezone* to +utc-zone+ to no avail
Gigolosu has joined #lisp
<fengshaun>
White_Flame, I guess I could, but then formatting is going to be messed up if someone happens to have appended the timezone
<White_Flame>
yep, was going to mention, but it is fairly obviuos
<fengshaun>
ideally I'd want timezone from the timestring, but if not present, then use the timezone I specify
<Hexstream>
Fare: Frankly, we could make Common Lisp even more powerful with just a few simple changes. This way, each lone wolf could do even more alone. ;P
<no-defun-allowed>
Is it really that bothersome to type funcall?
<oni-on-ion>
is this like CL21 ? if its again another lone-wolf project, how can it go anywhere beyond dreamland ?
spongiforma has quit [Client Quit]
<fengshaun>
I could copy-paste the parse-timestring code into my own project and modify it though
spongiforma has joined #lisp
<Hexstream>
no-defun-allowed: Actually, yes. Although, much less bothersome than lisp-1.
<oni-on-ion>
CL is a big project by many many groups and individuals and also time. current hardcore common-lispers are maybe around 50 total worldwide ?
<no-defun-allowed>
Well, if there were reasons for adoption other than "cause the 'modern' programming languages do that and we want to look like them", then it may be worthwhile to put such modifications in a CLtL3.
<no-defun-allowed>
Hexstream: I see.
<Hexstream>
Speaking of which, it would be great if we had package-local symbol aliases, so we could import FUNCALL as CALL and stuff.
<White_Flame>
I've seen a number of function call chaining macros
<Hexstream>
As a bonus, it would make reading and printing even slower!
waleee-cl has quit [Quit: Connection closed for inactivity]
<White_Flame>
oh wait, package aliasing, not symbol, n/m
<no-defun-allowed>
What would the symbol-name of CALL be?
<Hexstream>
FUNCALL?
<Hexstream>
If you use an alias, I mean.
narimiran has joined #lisp
<Hexstream>
It would be really great to be able to subclass ARRAY, PACKAGE, etc.
<oni-on-ion>
well there was a nice article about Lisp1 v. Lisp2 and all the many reasons for both sides. can't find it now, ironically
<oni-on-ion>
packages should be in a tree
<no-defun-allowed>
I can see why custom packages would be nice (I mostly want weak symbols, to be fair), but custom arrays and numeric types would get screwy with compiler optimisations, unless you start to over-specify types to get fast code, in which case you've kinda gained nothing.
<oni-on-ion>
root package: cl-user, keyword, etc; then symbols value can be package. idk if that is appropriate
<Fare>
Hexstream, but who is the target audience? And if you make changes to the language, what implementations will follow you?
<Hexstream>
I have many ideas for what I call "supercharged lisp-2", which would be like lisp-2 but with most of the advantages of lisp-1.
<Fare>
Especially if it's non-trivial changes. Or even simple changes, but with slightly different options than their legacy code relies on.
<Fare>
Things like first-class continuations? And how they interact with special variables?
<oni-on-ion>
it feels like CL21 but i dont know much about that. but there is an important fact here Hexstream : most of the great Schemes today (of which there are many more than CL implementations) have started as a "Better CL" -- and ended up scheme'd. perhaps start there first or find a meeting point half-way.
<Fare>
Or even just threads and special variables.
aartaka has joined #lisp
<no-defun-allowed>
Oh, I also want green threads, so that "asynchronous" code doesn't look stupid.
<Fare>
Or even just standardizing the corner cases of the pathname spec
mbomba has quit [Quit: WeeChat 3.0]
<Fare>
no-defun-allowed, welcome to Gambit.
<oni-on-ion>
or Guile or Chicken =)
<White_Flame>
right, CL isn't a language you can easily tweak at the fundamental feature level. More standard libraries would be nice, but QL is standard enough to allow any user to have the dependencies
<no-defun-allowed>
Fare: I mean, I'll take the rest of Common Lisp, but dammit I want nice socket code.
<Fare>
Or the ability to create symbol "aliases"
<no-defun-allowed>
And given that most of Common Lisp code has assumed synchronous/blocking sockets, it's difficult to use callback-based sockets with that code. Not so much for green threads; you could write blocking code like a normal person, and have an asynchronous backend.
<Fare>
Or to split the compiler from the rest of the system (yet pull it when needed?) (but not needed in surprising ways such as regular CLOS method evaluation)
<oni-on-ion>
so far Guile and Chicken have nearly all i'd want in a Lisp
<Fare>
I admit I didn't shop too much for a Scheme. I wanted Racket, or another Scheme with a good module system. Only Gerbil had it.
<no-defun-allowed>
I find myself using the compiler far too much to dispose of it.
<oni-on-ion>
no-defun-allowed, what we need is a feature to write code in Layers. so instead of (do-thing-1 ..) (do-thing-2 ..) for asynchronicity, they would be on the same line of code. like a Z layer in source files.
<Fare>
no-defun-allowed, I want to be able to deliver lean code.
<Fare>
Gambit allows that, for instance.
<oni-on-ion>
Chicken eggs have made me happy : but its the syntax changes there which are a huge boon for my useage.
aartaka_d has quit [Ping timeout: 258 seconds]
<Fare>
oni-on-ion, what kind of changes?
<no-defun-allowed>
When/if I make a native compiler for Netfarm, I will consider writing a presentation for the online Lisp meetings about compiling to Common Lisp.
<White_Flame>
oni-on-ion: layers would lead you to Befunge
<no-defun-allowed>
Since I've written approximately two of those (one chip-8 compiler, and one regular expression compiler).
<no-defun-allowed>
oni-on-ion: No, we just need asynchronous code to look like synchronous code, and for them to interoperate.
<oni-on-ion>
Fare, support for both ":keyword" and "keyword:" (coming from smalltalk/obj-c/english) , and also able to mix up any type of parens -- () [] {} <> depending on one's purpose. i am a visual coder, and Common Lisp is a bit too much like reading Prose to be efficient
<oni-on-ion>
no-defun-allowed, dunno. Ocaml and Julia both can do "automatic vectorising" given the data and algorithm are reasonable
<Fare>
Hexstream, I believe the issues with CL are, ultimately, social, and that CL attracts precisely socially inept people (me included) who are incapable of navigating those precise issues.
<Hexstream>
Fare: First, you definitely need your own Common Lisp implementation to lead the changes, and then you specify opt-in switches that can be activated to make certain changes to the language. Legacy code just doesn't activate any switches...
<oni-on-ion>
White_Flame, heh, well with say a shift+mousewheel to zoom in/out. so there is an active layer, and ones below and above. a bit like onion skinning used in animation
<no-defun-allowed>
oni-on-ion: Is that related to hiding the continuation?
<Fare>
Hexstream, so now you're going to reimplement CL, too?
<no-defun-allowed>
{-# LANGUAGE Welcome to GHC #-}
thmprover has joined #lisp
thmprover has quit [Client Quit]
<oni-on-ion>
no-defun-allowed, not sure. but in the links i sent forth yesterday on the ocaml multicore work, it says stuff that sounds quite great
<no-defun-allowed>
Fare: I want to modify SICL to use m:n green threads, and I sort of have a plan to do that. But you could get away with modifying only the stuff above HIR to make language changes.
<Hexstream>
Fare: Well, a fork of SBCL would be sufficient, but Common Lisp on Cloudflare Workers (WebAssembly) would just kill everything. https://workers.cloudflare.com/ Even fucking Haskell is on Cloudflare Workers!!
<oni-on-ion>
before that i think CL needs to be able to do multiple images. prolog/erlang naturally do the green threading easily because of this "VM". oh and now there is ocaml for BEAM...
<no-defun-allowed>
No fucking way I'm ever putting anything on CloudFlare.
<oni-on-ion>
sounds like Geocities or MegaUpload
<lotuseater>
oh didn't knew OCaml runs now on BEAM too
<no-defun-allowed>
How do they compile reference cells?
<oni-on-ion>
ocaml is coming up /fast/ -- theres a software foundation now just created, too
<Hexstream>
no-defun-allowed: Why not? I have everything on Cloudflare. 25+ subdomains across 4 main websites.
<Hexstream>
Around 10% of the web is behind Cloudflare...
<no-defun-allowed>
But you appear to love centralisation, so that wouldn't convince you of anything.
<Hexstream>
They have native support for Tor these days, I seem to remember.
<lotuseater>
ah nice, thx oni-on-ion :) and i already tried LFE on BEAM too
<oni-on-ion>
lotuseater, cool, same here =) not elixir though, blech
jello_pudding has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
Furthermore, in its current state, WASM is a huge step back from compiling to machine code, insofaras it is difficult to implement Lisp control flow. (But phoe and ioa at least are trying to change that, so it's not all horrible.)
<loke[m]>
oni-on-ion: I have used Elixir for one project that didn't really go anywhere. It did make me want to use it again though. I just wish I had a project to use it with. My main two projects now is Common Lisp and Kotlin.
<Hexstream>
no-defun-allowed: I do love centralization, in fact I want to move my origin from DigitalOcean to Cloudflare Workers.
<no-defun-allowed>
Disgusting.
<oni-on-ion>
loke[m], cool. for BEAM i did mainly pure Erlang. i rather enjoyed it=)
<Hexstream>
Cloudflare is eating the world! Deal with it. 😎
<lotuseater>
ongoing centralization is programmed death of the web
<oni-on-ion>
meanwhile IRC
<no-defun-allowed>
I will deal with it, and I will deal with it promptly, should my own plans for 2021 transfer into reality.
<loke[m]>
oni-on-ion: I wanted to enjoy Erlang, but it had some rough edges. Also, the Emacs development environment for it had bugs and was unmaintained. Elixir is just more programmer-friendly, and the Emacs integration was nice.
jello_pudding has joined #lisp
<oni-on-ion>
to be pendantic. are you guys talking about the world wide web? or the actual TCP/IP and IPvX network ?
<oni-on-ion>
loke[m], yep. there are a couple large offerings for erlang+emacs but they seemed to have faltered briefly. afaik today they are fine (distel being one?)
<oni-on-ion>
not sure, don't want to be off topic
<no-defun-allowed>
TCP/IP is pretty good - the Internet was funded cause it was sufficiently fault tolerant (owing in part to decentralisation, and clever abstraction over routing).
<no-defun-allowed>
But I abstract over that just to be sure.
<loke[m]>
oni-on-ion: I see. I haven't investigated Erlang on Emacs for a few years now. I do feel that Elixir only adds to what makes Erlang nice, and there seems to be no drawbacks.
<oni-on-ion>
the "WWW" aspect (interlinked http urls) is a whole other ball game. it is *mainly* an advertising platform. that's it. like a magazine. big sites are like television networks. then it makes more sense. websites suck.
yonkunas has quit [Quit: Connection closed for inactivity]
<oni-on-ion>
loke[m], for me it is the syntax. i cannot stand begin,begin,begin [do something] end end end end end
<loke[m]>
*no-defun-allowed*: Are you on this channel via Matrix? I can see "...in typing" messages from you :-)
<oni-on-ion>
i can see open and closed brace/paren way more efficiently than reading prose
<no-defun-allowed>
loke: Yes.
<loke[m]>
*no-defun-allowed*: It works remarkably well, don't you think?
<oni-on-ion>
(i am a visual coder and ocaml is hyper-fast to read. like C to me, easy to instantly see a page of code and know what is going on. with CL for eg it has to be "readed" and thats just not my brain)
<no-defun-allowed>
loke: They disabled online/offline status markers on matrix.org because it was too performance-intensive. But I suppose typing notifications work.
<loke[m]>
*no-defun-allowed*: Yeah, I was surprised to see it.
<oni-on-ion>
yuck. so it turns into facebook
<no-defun-allowed>
oni-on-ion: "it turns into Discord" would be more correct.
<loke[m]>
I also like how it maps @-whatever to the typical IRC style with :.
<loke[m]>
*no-defun-allowed*: it means that people on IRC will br griding their teeth when someone from Matrix joins.
<oni-on-ion>
because Discord turned into facebook then ? "Typing... " and also "Seen msg" etc.
<loke[m]>
"will _not_ be grinding their teeth"
jrm has quit [Quit: ciao]
Oladon has quit [Quit: Leaving.]
<no-defun-allowed>
Interesting, when you ping me I still have earmuffs on my name. I don't have earmuffs on my IRC nick.
<loke[m]>
I see. That's a discrepancy then.
<loke[m]>
So the integration isn't perfect.
<oni-on-ion>
speaking of, should check email now
<no-defun-allowed>
It's surprisingly good, I only have to hop on irssi when matrix.org goes down.
akoana has left #lisp ["Leaving"]
<loke[m]>
However, if you go the #apl channel, you'll see it's linked with the Stackoverflow chat. That integration is absolutely awful. There is a single user on the channel that relays messages from SO and vice versa.
wxie has joined #lisp
<lotuseater>
so no-defun-allowed you're a parameter
<loke[m]>
no-defun-allowed: Run your own server, that's what I do. :-)
<no-defun-allowed>
I think some of the other bridges have less "hooks" into matrix.org, like they can't fabricate a user for each IRC user.
<loke[m]>
That said, the bridge is probably running on the matrix.org machine, so it probably doesn't matter.
<no-defun-allowed>
loke: I got bored enough of "run your own server" that I wrote a distributed object system, a manual for that object system, and then a nasty comment about it in the manual.
<loke[m]>
I don't run many servers, for the Matrix one is nice.
<loke[m]>
I want to set up my own Peertube and Pixelfed servers though, mainly as part of my project to degooglify myself.
<oni-on-ion>
err so back to erlang. i rather enjoyed its syntax, same with most of prolog. would like to see that on BEAM
<no-defun-allowed>
Nothing really personal, but federation is a bit stupid with one user per server.
jello_pudding has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
I'd rather have no central point of failure rather than own the central point of failure; the latter is too much work.
<loke[m]>
no-defun-allowed: Well, sure. For more people definitely.
<no-defun-allowed>
Well, the same goes for too many users per server. In my opinion, the sweet spot is 100-1000 users a server, but some people would say 10-100 is more appropriate.
<loke[m]>
*no-defun-allowed*: Sure, but then you have to trust that single point of failure. Right now, for example, my videos are mainly on peertube.mastodon.host, but there are some issues there and I'm not sure I can rely on them staying up.
<loke[m]>
*no-defun-allowed*: Which mastodon server are you on?
Hexstream has left #lisp [#lisp]
<no-defun-allowed>
I am currently on eldritch.cafe, but I used to be on ponies.im (I still have a Matrix account there). Also, should we take it to #lispcafe?
<no-defun-allowed>
lotuseater: Yes, when you bind *no-defun-allowed\* to a truthy generalised boolean, you cannot DEFUN, as you might expect from the name.
<no-defun-allowed>
Matrix clients hate that name, and so does the IRC bridge; it didn't drop the escape \ to avoid italics.
<loke[m]>
*no-defun-allowed*: are you able to join #lispcafe from Matrix? It required a registered nick.
<lotuseater>
when using the freenode irc client earmuffs get things to bold
<loke[m]>
I'm not sure you can do that via matrix?
<no-defun-allowed>
Yes, you need to talk to talk to NickServ, and/or tell @appservice-irc:matrix.org to remember your password.
<loke[m]>
lotuseater: that's neat, because that's what *the Matrix bridge* also does.
<loke[m]>
Oh wait, it makes it italics. Horrible.
<no-defun-allowed>
Sure you can, the former just requires sending a private message to @freenode_NickServ:matrix.org
<lotuseater>
loke[m]: yes like in org mode, earmuffs for bold and slash for italics
<no-defun-allowed>
Matrix uses Markdown, so one set of earmuffs or underscores is italic, and two sets are bold. Three are both.
<loke[m]>
Horrible.
<loke[m]>
Markdown is an absolutely awful syntax,.
<loke[m]>
* Markdown is an absolutely awful syntax.
jrm has joined #lisp
<lotuseater>
some may get the idea it's some kind of programming language
<loke[m]>
The real issue is that the format is non-deterministic.
<loke[m]>
I've come to really enjoy asciidoc.
terpri has quit [Ping timeout: 260 seconds]
terpri has joined #lisp
aartaka_d has joined #lisp
tessier has joined #lisp
tessier has joined #lisp
<no-defun-allowed>
loke: Well, someone's bound to get annoyed if we keep talking about Matrix here. How about budget #lispcafe (#symbolics2:ponies.im) instead?
aartaka has quit [Ping timeout: 272 seconds]
terpri has quit [Ping timeout: 260 seconds]
zcheng3 has joined #lisp
<oni-on-ion>
use YAML instead
frost-lab has joined #lisp
terpri has joined #lisp
jello_pudding has joined #lisp
<loke[m]>
oni-on-ion: YAML for what? (I personally find YAML to be just as horrible as JSON (although, on different grounds).
<no-defun-allowed>
I want nothing to do with data representations.
<oni-on-ion>
instead of markdown. as just mentioned .
XachX has quit [Read error: Connection reset by peer]
drmeister has quit [Read error: Connection reset by peer]
drmeister has joined #lisp
XachX has joined #lisp
gzj has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
<srandon111>
guys what do you think about clojure ?
<srandon111>
pros and cons ?
aeth has joined #lisp
<no-defun-allowed>
cons: no CONS
<lotuseater>
:D
<easye>
no-defun-allowed: +1
<no-defun-allowed>
pros: gets you hired maybe
<lotuseater>
srandon111: by statistics one of the best paid languages
<srandon111>
no-defun-allowed, and then? what's the disadvantage of not having cons?
<lotuseater>
not CONSequent
<srandon111>
lotuseater, i don't understand
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<srandon111>
lotuseater, i don't like the fact of having huge startup times
<srandon111>
damn
<lotuseater>
it's kind of a joke
<no-defun-allowed>
srandon111: Well, it was a pun on the name of the CONS cell, which Clojure doesn't really expose. But you also lose out on object-oriented programming, which I think can in fact be made concurrent (eg actors).
<oni-on-ion>
i had fun with clojure, its nice to work with. aside from the java errors/backtrace (which may be different now) and the startup times are abysmal
<lotuseater>
yeah but startup time is mostly once, as for using emacs
<srandon111>
lotuseater, i am into developing cli apps
<oni-on-ion>
ClojureScript was alright too
<srandon111>
and its startup time is making me want to learn common lisp
<oni-on-ion>
CL startup time isnt the greatest either, but much better than Clojure
<lotuseater>
yeah then first learn how everything fits together
<srandon111>
because i like clojure and its ecosystem, but it does not seem friendly for the kind of cli apps i want to make
<srandon111>
for example... i cannot wait 4 seconds to show the help of a ocmmand line app come on guys
<oni-on-ion>
^ zactly
<sgibber2018>
Is it really that long? Why?
<no-defun-allowed>
I think it has to do with the Java virtual machine, because ABCL also leaves you hanging for a while.
<sgibber2018>
That was my guess, but I wanted to ask just to be sure
nkatte has quit [Remote host closed the connection]
<sgibber2018>
The only LISP I've ever used is Scheme, if that counts.
<srandon111>
sgibber2018, why it should not count?
<no-defun-allowed>
oni-on-ion: I mean, I can start a SBCL image and start a few threads in 50ms, which is acceptable if you're not running it in a loop.
<srandon111>
schemes downside is the lack of 3rd party stuff and lack of good documentation imho
<sgibber2018>
srandon111: I assume it would, but that's how much of a non-expert I am.
<sgibber2018>
I just found a Scheme textbook at the used book store one day and went through it and loved it. Since then I've been bummed I can't find a use for it.
<no-defun-allowed>
And the other big con is that it's touted as "modern" and the community is a disaster for online discourse. But I digress.
scrungyforma has joined #lisp
<lotuseater>
there are some good scheme native compilers
scrungyforma has quit [Client Quit]
spongiforma has quit [Ping timeout: 258 seconds]
<srandon111>
no-defun-allowed, yes it's true
<srandon111>
there is people who think that guile docs are good
<srandon111>
damn there isn't half of an example in that doc
bitmapper has quit [Quit: Connection closed for inactivity]
<sgibber2018>
The book I found at the store was by the guy who wrote chez scheme so that's the one I've always used for fiddling around. I have no idea what the relative merits of them are. Except that chicken is supposed to be pretty neat.
<no-defun-allowed>
My favourite co-author and I have a bet that most of the "bags of unlabelled data" stuff would be better served with prototypes, and I can in fact model time quite well with CLOS. To some extent, the result looks, nay, is basically transactional OOP: https://gitlab.com/Theemacsshibe/cl-worlds
zcheng3 has quit [Ping timeout: 246 seconds]
<oni-on-ion>
eh, on cold boot, SBCL took about 6 seconds but i am on regular HDD and quicklisp might have some stuff going on during load
<oni-on-ion>
average now after its in recent cache, 0.635 second (635 ms?)
andreyorst has joined #lisp
wxie has quit [Ping timeout: 258 seconds]
curiouscain has quit [Ping timeout: 240 seconds]
curiouscain has joined #lisp
<no-defun-allowed>
Yeah, try (save-lisp-and-die "/tmp/foo" :executable t :toplevel (lambda () (print "Hello world!"))) or something like that.
<no-defun-allowed>
Hey, that's <10ms from a tmpfs.
tempest_nox has quit [Read error: Connection reset by peer]
<beach>
Does Clojure have an independent standard?
<beach>
As I emphasize in my talks to industry, a project leader who chooses a language without an independent standard should be fired.
<beach>
Unless, of course, that person made a risk analysis that takes into account the possibility of having to rewrite the project code when it turns out that the language that was chosen was abandoned, or was modified in such a radical way that the code no longer works.
<beach>
Or legal costs when the company is sued (by Oracle, maybe?) for using a proprietary language or tool set.
<no-defun-allowed>
I dunno, the former situation is apparently an advantage according to recent #lisp discussion.
<beach>
"former"?
<beach>
Which one is that?
<flip214>
no-defun-allowed: I'm arguing for SBCL images over Java software because the HTTP port is up after <15msec, which is great in a PaaS or SaaS...
<no-defun-allowed>
My apologies: "the possibility of having to rewrite the project code when it turns out that the language [...] was modified in such a radical way that the code no longer works"
<beach>
Hmm.
KREYREEN has quit [Read error: Connection reset by peer]
andreyorst` has joined #lisp
andreyorst` has quit [Remote host closed the connection]
KREYREEN has joined #lisp
andreyorst` has joined #lisp
andreyorst` has quit [Remote host closed the connection]
andreyorst` has joined #lisp
vsync has quit [Ping timeout: 265 seconds]
mgxm has quit [Ping timeout: 264 seconds]
vsync has joined #lisp
Nilby has joined #lisp
andreyorst has quit [Ping timeout: 256 seconds]
liberliver has joined #lisp
<loke[m]>
*no-defun-allowed*: that sounds like Rust?
<beach>
loke[m]: Why do you give no-defun-allowed earmuffs?
<loke[m]>
beach: becaue n-d-f is using Matrix to connect to IRC, and the Matrix username is no-defun-allowed. The username is mapped to IRC as no-defun-allowed.
<beach>
I'm lost. But I guess it's not important.
wxie has joined #lisp
<loke[m]>
beach: Matrix is a federated chat software. It can link to IRC quite effectively, and integrates quite well. However, there are some places where incompatibilities shine through. One of those cases is when your Matrix username is not compatible with IRC. n-d-f has asterisks in the Matrix username, which is not allowed in IRC. Since I also use Matrix, I see the asterisks.
jprajzne has quit [Quit: jprajzne]
mbomba has joined #lisp
jprajzne has joined #lisp
<beach>
I see (I think).
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
<phoe>
Xach: when I made a GECO repo you mentioned that gpwwjr was a person of the Old Ways
<phoe>
now there's an official git repo from him!
mbomba has quit [Quit: WeeChat 3.0]
dmc00 has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 258 seconds]
shifty has joined #lisp
treflip has joined #lisp
mgxm has joined #lisp
Blukunfando has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
<ebrasca>
Morning!
aartaka has joined #lisp
<beach>
Hello ebrasca.
<phoe>
hello
Duuqnd has joined #lisp
aartaka_d has quit [Ping timeout: 258 seconds]
KREYREEN has quit [Remote host closed the connection]
shka_ has joined #lisp
zacts has joined #lisp
zacts has quit [Client Quit]
mbomba has joined #lisp
ljavorsk has joined #lisp
mbomba has quit [Client Quit]
jibanes has quit [Ping timeout: 258 seconds]
jibanes has joined #lisp
Fare has quit [Ping timeout: 258 seconds]
shifty has quit [Ping timeout: 264 seconds]
harlchen has joined #lisp
Fare has joined #lisp
pve has joined #lisp
gproto23 has joined #lisp
susam has joined #lisp
<no-defun-allowed>
beach: My Matrix nick has earmuffs, and pinging me copies that instead of the IRC nick.
random-nick has joined #lisp
<no-defun-allowed>
loke: Well, credit where credit is due, don't they have...three year epochs as "releases"?
<beach>
no-defun-allowed: Got it.
<no-defun-allowed>
It used to be #'no-defun-allowed, but why would that be a function?
<beach>
Yeah, no reason.
<no-defun-allowed>
(A rhetorical question. Earmuffs make some more sense.)
gproto23 has quit [Quit: Leaving]
<no-defun-allowed>
Also, note that IRC nicks and Matrix nicks are usually not the same (which, from my reading, may be suggested by "mapping to IRC"). Usually they have [m] at the end, which is a story I told before - actually, no, they might be similar.
Fare has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
And Matrix nicks may also be different between rooms - I have my first name as a nick in some. What happens if I set a different nick for #lisp?
<no-defun-allowed>
Nothing. Maybe there is something else I have to change to change my IRC nick.
rdd has joined #lisp
jonatack has quit [Remote host closed the connection]
<spal>
This is my Freenode IRC nick ...
<susam>
... and this is my Matrix nick (also registered in Freenode)
<ck_>
sounds a little off topic for #lisp
* no-defun-allowed
evacuates the contents of Matrix to newspace^W#lispcafe
jonatack has joined #lisp
<susam>
On Matrix, you can open a private chat with @appservice-irc:matrix.org and run commands on it (like !nick) to change the Freenode-side nick of your Matrix user.
<susam>
ck_: Offtopic indeed. Sorry for the digression.
<beach>
I agree with ck_.
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
spxy-m has left #lisp ["User left"]
Fare has joined #lisp
spxy-m has joined #lisp
spxy-m has left #lisp ["User left"]
Fare has quit [Ping timeout: 260 seconds]
gigetoo has quit [Ping timeout: 264 seconds]
gigetoo has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
rdd has quit [Ping timeout: 246 seconds]
datajerk has quit [Ping timeout: 256 seconds]
jpli has quit [Remote host closed the connection]
aeth has quit [Ping timeout: 272 seconds]
aeth has joined #lisp
datajerk has joined #lisp
Lord_of_Life has joined #lisp
Lord_of_Life has quit [Changing host]
waleee-cl has joined #lisp
<pve>
beach: Hi, you've mentioned implementing a compiler using the "full language" (or something to that effect). Can I read more about this approach somewhere?
<beach>
pve: Let me check what I have written that might work. Hold on...
<pve>
beach: thanks, there's absolutely no rush
<beach>
I don't see anything that is specifically addressing this point. But if you join #sicl I can explain a bit more. If that way of doing it is convenient for you, of course.
<pve>
certainly
<beach>
There is not much to say about it, in fact. The main thing is to make the code idiomatic and to create a bootstrapping procedure to make it operational.
pbgc has joined #lisp
orivej has joined #lisp
<phoe>
@everyone: ELS 2021 is going to be online. I just got a response from Didier.
<beach>
Great!
<easye>
phoe: good.
heisig has joined #lisp
<phoe>
...maybe I should not have mailed Didier after all though
ljavorsk has quit [Ping timeout: 256 seconds]
<phoe>
he asked me a tough question
<phoe>
the question was, given my experience with streaming Lisp stuff, would I like to stream more Lisp stuff
<flip214>
phoe: whether you'll cause fist fights with your presence?
<flip214>
oh, not that tragic then
<phoe>
flip214: not that, but I enjoyed your post in face of the current dynamic context
gzj has quit [Remote host closed the connection]
<easye>
phoe: I'd be happy help stream ELS2021
<phoe>
easye: go tell Didier then!
gzj has joined #lisp
<phoe>
I accepted his offer, but I'll surely need a backup in case my computer or connection decide to fail.
<easye>
I DM'd him yesterday on Twitter. Can you /MSG me the email address you are using.
<phoe>
easye: added you to the mail thread instead.
<easye>
Got it.
<flip214>
phoe: glad that I can enlighten your mood!
wxie has quit [Remote host closed the connection]
<phoe>
Didier: «Thanks again for "volunteering" :D»
<phoe>
yeah, right
<flip214>
phoe: you got volunteered by all of us
<flip214>
by popular vote
shifty has joined #lisp
<flip214>
and as soon as ELS happens in real world again, you might even get bought a beer or a half
<flip214>
but the current ETA for that is 2038 or so
<phoe>
isn't that when the unix time runs out?
<phoe>
which is kinda, uh
iskander- has joined #lisp
<beach>
Nah, we will all be vaccinated by the end of 2021.
<phoe>
foreshadowing
<flip214>
only for 32bit values, which are more and more uncommon
<flip214>
even javascript has 53bit for integers defined
<phoe>
in yer yet other words, something that you can operate on, return from functions, pass to functions
chkhd has joined #lisp
<beach>
Store in a variable.
<phoe>
in yet yet yet other words, a datum can be a number, a string, a list, an array, a symbol, a cons cell, a hash-table, a class, an instance, ..., ...
<nij>
phoe: I get that. Perhaps I really have to look into the source of Lisp to really grab what it is. I won't do that now.
<beach>
nij: There is no "source of Lisp". Only of individual implementations.
<phoe>
^
<nij>
Oh yes. should say source of any implementation.
<Bike>
don't overthink it. a datum is just a manipulable thing of some kind.
<phoe>
if anything, you might want to look into the tests of Lisp
<phoe>
to figure out how some operator or data structure should behave.
hiroaki has quit [Ping timeout: 240 seconds]
<beach>
nij: But the concept of an object/datum is very simple. It is anything that you can pass to a function, return from a function, store as the value of a variable, store in an array, store in a slot.
<Bike>
defining "datum" for lisp is like trying to define the word "object" in normal english. it's like, a thing.
<nij>
But there must be some of them that couldn't be implemented within lisp.
<nij>
OH THIS! ^^^^^^^^^^^^^
<phoe>
good
<Bike>
what is the purpose of this definition?
<Bike>
of "primitive"?
<nij>
Bike: just curious
<Bike>
i mean, it depends, doesn't it? on a modern computer basically everything is going to be encoded as a small integer or series of small integers
<Bike>
that doesn't exactly help you with language semantics
<nij>
0 and 1
<nij>
No it won't help indeed.
<Bike>
right, but this is like learning how to cook and starting by asking what quarks things are made out of
<nij>
I'm just curious what's happening at the bridging layer between lisp and one step below.
<nij>
Bike: I did that and became a researcher xD
<nij>
Academic people like me are doomed to procrastinate for stupid reasons :'(
<Bike>
it's not like chemistry isn't relevant to cooking, but if you're at the point of not knowing how to boil water it's not going to do you much good, you know what i mean?
<nij>
But I do like the graph phoe posted
<nij>
Bike: yeah I get you
<Bike>
phoe's graph has nothing whatsoever to do with the "bridging layer" you mentioned. it's just the language semantics.
<nij>
Uh.. at the top of each connected components.. aren't they the primitive types?
aartaka has quit [Read error: Connection reset by peer]
<Bike>
nope, those are the superclasses.
<Bike>
for example this says that REAL and COMPLEX are NUMBERs
<nij>
:O :O :口
<Bike>
but that doesn't mean there's a "primitive" "number" type or anything
<nij>
I admit I'm just a miserable researcher who just start to realize that every theory is essentially empty within itself, and probably the most true thing are the objects in languages like Lisp.. at least a foundation can be fetched..
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
kaftejiman has joined #lisp
<nij>
(Don't take it too seriously :) but this is really what I am at.. it should go to #lispcafe though.. so I'll stop here.
<Bike>
i understand your thought process and i don't think it's going to work. lisp is an abstraction layer. there are any number of ways an implementation could decide to implement those semantics on actually existing computers.
<Bike>
this is true of C or any other language as well really, but the C virtual machine is relatively similar to actual machines, so people forget
gzj has quit [Remote host closed the connection]
<nij>
Bike, you just destroyed my last hope. xD
tfb has quit [Read error: Connection reset by peer]
<nij>
Nah just kidding. I get that..
gzj has joined #lisp
<phoe>
nij: do you understand what an axiom is?
<nij>
But somehow I feel the urge to get to understand the roots of the current abstraction level I'm at.
<phoe>
in logic, in proofs, in mathematical reasoning
<nij>
phoe: I am a mathematician. So.. yes.
<phoe>
good
<phoe>
then a lot about CL type theory is actually axioms.
gzj has quit [Remote host closed the connection]
<nij>
Yeah but I don't really like axioms..
<Bike>
what an odd thing to say.
tfb has joined #lisp
<phoe>
symbols exist as a type and that type is allowed to be primitive so not defined in terms of anything else - or, in other words, via built-in-class.
gzj has joined #lisp
<phoe>
s/that type/that class/
<phoe>
s/type/class/
<phoe>
that's all. there's no more proof, that's an axiom of ANSI Common Lisp.
<nij>
Bike: ? what's odd
gzj has quit [Remote host closed the connection]
hiroaki has joined #lisp
<phoe>
there's a ton of other axioms like that, and what you're diving into when you jump into implementation sources is just details of their concrete implementation.
<nij>
phoe: thanks ..
<Bike>
in math terms this is like you want to learn to multiply so you go "ok, so numbers are defined as sets of sets, right?" like no, that's just if you use set theory instead of category theory or whatever else, and even then there are any number of possible representations of numbers as sets
gzj has joined #lisp
<nij>
Bike: that's exactly what made me feel void.
gzj has quit [Remote host closed the connection]
<nij>
It feels like whether things exist isn't the point, but how they behave is.
<Bike>
well, yeah, pretty much.
<phoe>
obviously
gzj has joined #lisp
<phoe>
can you prove you're self-aware?
<Bike>
sorry, i guess. but i can't fix that by lying to you and telling you that actually the one true way to represent numbers is like bla bla bla.
<phoe>
or is that only inferable from your behavior?
gzj has quit [Remote host closed the connection]
<nij>
phoe: I don't even know what's self-aware.. (plus we don't need a proof for everything..
<nij>
Bike: fair.
gzj has joined #lisp
<phoe>
a Common Lisp implementation is allowed to implement CL:+ by sending the question over the Internet as a question to Amazon Mechanical Turk, waiting for the response, and returning the value that was produced this way
<phoe>
and that will work, ANSI-TEST are gonna pass on this
<nij>
:(
<phoe>
and the only downsides to it are that you're gonna be real puzzled when you look at the implementation sources for that.
<phoe>
and that it's gonna be slow and expensive like holy hell.
<aeth>
Just crowdsource it for free on Twitch chat. You could even use the name twitchplayscommonlisp
<nij>
phoe: I'm warned. I won't do that too soon!
gzj has quit [Remote host closed the connection]
<phoe>
aeth: touche
wsinatra has joined #lisp
<beach>
nij: What do you consider as being one step below Lisp?
<aeth>
the correct answer is (1- *lisp*)
<nij>
beach: The language used in the source code of whichever lisp implementation.
<nij>
aeth: approximately yeah, (1- *lisp*)
<phoe>
nij: well
<beach>
nij: So for SBCL and SICL, that would be Common Lisp.
<phoe>
beach gon teach you a lesson in a moment
<phoe>
the only parts of SBCL written in C would be the garbage collector and low-level stuff for interfacing with the OS API
<phoe>
and as far as I know SICL wants to get rid even of those
<aeth>
afaik, SBCL writes the GC in C so that you're able to debug it if things go wrong
<aeth>
it's absolutely not necessary to write a GC in C
<beach>
Indeed. The SICL garbage collector is written in Common Lisp.
<nij>
@@ how about the special forms?
<nij>
I get that most of any Lisp implementation can be writting in the Lisp
<beach>
The compiler (written in Common Lisp too) handles them specially.
<nij>
Who compiled the compiler?
<phoe>
the previous compiler
<beach>
It was compiled on a Common Lisp system.
<phoe>
e.g. SBCL
<phoe>
or CCL
<phoe>
or ECL, or CLISP, or ABCL
<nij>
Lol so Common Lisp has been used to bootstrap Common Lisp implementations several times?
<phoe>
it's used for that purpose all the time
<phoe>
like, SBCL compiles SBCL all the time
<nij>
Come on there must be a starting point when common lisp needs to be bootstrapped by other languages.
<phoe>
uh
<phoe>
what do you mean by "starting point"?
<beach>
nij: Maybe 50 years ago.
<nij>
beach: yeah then that's what I'm talking about
<phoe>
so, yes, obviously there was such a point somewhere someday
<beach>
But you won't find any trace of those anymore.
<phoe>
that's how evolution works
dbotton has joined #lisp
<phoe>
following this logic there is also a point when humans weren't human, but suddenly, bam, there is a human
<nij>
beach: REALLY? It's so hard to find?!
<nij>
phoe: LOL
<phoe>
I mean, ECL compiles from portable C
<shinohai>
CLISP, bootstrapping you into sbcl since 1999 (tm)
<phoe>
so does CLISP
<nij>
This is what I'm looking for!
<nij>
I regain meaning from ignorance!
<phoe>
but other implementations don't do that because writing a lot of Lisp code in C is, uhh, ugly
<phoe>
that's why SBCL bootstraps from Lisp plus a small C module
<phoe>
CCL bootstraps from CCL plus a small C module
<phoe>
SICL bootstraps from Common Lisp and abhors C modules altogether
<phoe>
so, you know - it isn't universal.
<phoe>
and you still need a C compiler, too.
<phoe>
who's gonna bootstrap that one?
<nij>
You must love Lisp so much to know all the stories of the ancestors.
<phoe>
it's more like just common knowledge, it sinks into you over time as you chat with lispfolk and read about stuff
<phoe>
unless you're also interested in it, at which point it's 10% of the required time
* phoe
afk
<nij>
Someone should make a lisp out of machine code.
<aeth>
nij: It's the same issue with C. What compiled the first C compiler in a chain of C compilers? Well, just like with CL, it's either (1) another compiler of the same language, (2) a compiler written in another high level language, or (3) a compiler hand-written in assembly or machine code
<phoe>
nij: why
<phoe>
that would be counter productive
<aeth>
Ultimately, the chain of compilers has to be traced to #3
<aeth>
(OK, #3 might have also been an interpreter)
<phoe>
also, who created that machine code
<nij>
phoe it feels more meaningful
<phoe>
and who created the machine that executes it
<aeth>
nij: It's possible that some Common Lisp compiler chains trace their origin back to a pre-CL Lisp like Maclisp or Interlisp
<phoe>
nij: meaningful? wat
<phoe>
why
<phoe>
meaningful for what exactly
<phoe>
"If you wish to make apple pie from scratch, you must first create the universe." -- Carl Sagan
<aeth>
The general solution to that issue is deterministic builds, but the CL community hasn't really talked about that yet afaik. And it's a harder problem in CL because the product is image-based
acolarh has quit [Ping timeout: 260 seconds]
orivej_ has joined #lisp
<nij>
aeth: What does deterministic builds mean?
orivej has quit [Ping timeout: 256 seconds]
<aeth>
nij: In practice, it means that it makes it so you shouldn't care about how you got the resulting product (hand-compiled, a random C compiler, another CL compiler, etc.) because it should build the same every time.
<nij>
i see
acolarh has joined #lisp
<aeth>
Well, for a given compiler. But it means you don't have to care about the prior chain, i.e. the compiler's compiler
ljavorsk_ has quit [Ping timeout: 260 seconds]
defunkydrummer has joined #lisp
<aeth>
nij: If a CL compiler is compiled in some CL implementation, and then it recompiles itself in a deterministic way (the same source producing byte-for-byte identical output) before it's used for anything else, then it doesn't matter how it got there.
<aeth>
It could've gotten there from a time-consuming hand-compilation process, CLISP, ECL, CCL, SBCL, etc., and it wouldn't matter.
notzmv has quit [Read error: No route to host]
<aeth>
And you could compile it two different ways and compare to ensure that you can actually trust it.
notzmv has joined #lisp
<nij>
(Beautiful read by Thompson :)
<nij>
I think I understand the chicken-egg problem at the next level today.
<jackdaniel>
probably because your code is not tasty ,)
<jackdaniel>
all variables must be defined before setting them
<jackdaniel>
i.e (defparameter tasty nil)
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<nwoob>
oh ok
<nwoob>
thanks
<jackdaniel>
putting only (setf tasty nil) without defining the variable is like assigning a value to undeclared variable (but cl is more forgiving usually)
defunkydrummer has quit [Ping timeout: 258 seconds]
gaqwas has joined #lisp
srandon111 has quit [Ping timeout: 260 seconds]
tisskenzen has joined #lisp
epony has joined #lisp
srandon111 has joined #lisp
nwoob has quit [Ping timeout: 256 seconds]
<harlchen>
sry if this is the wrong chan, but hunchentoot/vanilla vs. hunch..+easy-routes vs. h..+ningle vs. clack+lack.component/+builder vs. ... ; for a new web-app/parenscript for a ~cl-noob ?
X-Scale` has joined #lisp
Demosthenex has quit [Ping timeout: 240 seconds]
X-Scale has quit [Ping timeout: 264 seconds]
X-Scale` is now known as X-Scale
Demosthenex has joined #lisp
gxt__ has quit [Ping timeout: 240 seconds]
gxt__ has joined #lisp
<flip214>
harlchen: I'm using HT + HT-quux - I'm happy enough with the easy-handlers, but if you have lots of routes you might wants some library on top
<harlchen>
will investigate quux, thx
<harlchen>
i'm still orienting myself partly by the cookbook and awesome-cl :)
<flip214>
minion: tell harlchen about hunchentoot-quux
<minion>
Sorry, I couldn't find anything in the database for ``hunchentoot-quux''.
amb007 has quit [Read error: Connection reset by peer]
<defunkydrummer>
rumbler31_ oh, i didn't read the "GIS" part of your question
amb007 has joined #lisp
<defunkydrummer>
rumbler31_: here's a list of GIS libs, https://www.cliki.net/geospatial . This is cliki (old site) so there must be some more libs too, but it gives you a starting point
srandon111 has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aartaka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
amb007 has joined #lisp
hal99999 has quit [Quit: hal99999]
zacts has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
karlosz has quit [Ping timeout: 264 seconds]
rgherdt has joined #lisp
aorst has joined #lisp
narimiran has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
andreyorst has quit [Ping timeout: 272 seconds]
<tisskenzen>
okay, i'm writing a syntax-case macro for my pet guile script, and have found a need to add several keywords into the pattern of the clause, because this is much cleaner to read
jpli_ has joined #lisp
jpli has quit [Ping timeout: 272 seconds]
<tisskenzen>
there's a problem of keyword permutations and repeating the expression after the pattern is written
<tisskenzen>
nvm, maybe i'll solve this myself
jw4 has quit [Read error: Connection reset by peer]