<beach>
hashfunc65d: Did you study the error message?
<Devon>
dbotton: https://emacsformacosx.com has many, many versions. Type Escape Colon emacs-version return
<dbotton>
did that it says 28.1
<Devon>
dbotton: Where did you get slime?
<dbotton>
quicklisp
<hashfunc65d>
beach: yes, "Derived type of REST is (VALUES LIST &OPTIONAL), conflicting with its asserted type NUMBER." and i'm not sure how that helps me solve the problem
<Bike>
hashfunc65d: REST is a list. + accepts only numeric arguments.
<slowButPresent>
dbotton: installing slime with git sloved the issue for me. commit 48bfe6cccfdf879cd7137b00eb2ca160665a92f8
<Devon>
dbotton: You did M-x load-file Ret ~/quicklisp/slime-helper.el Ret?
<dbotton>
trying now
<Bike>
(+ 4) is valid, for example, and gets you 4. (+ '(1 2 3)) is not, and will get you a similar error.
<beach>
hashfunc65d: What Devon and Bike said.
<beach>
hashfunc65d: Did you not know that the value of the &REST variable is a list?
<hashfunc65d>
ah i could have sworn that i tried (DEFUN SHA256-+-MOD2^32 (&REST REST) `(MOD (+ ,@REST) (EXPT 2 32))) and it didn't work
<hashfunc65d>
but i just tried it again, and it compiles perfectly
<beach>
hashfunc65d: But now you are not returning a number.
<hashfunc65d>
beach: ah yup you're right. the problem still isn't solved
<Bike>
hashfunc65d: you're not passing a list to the + function there. you are taknig a list, like (1 2 3), and splicing it into a form, giving you (+ 1 2 3) or something. and that is subsequently evaluated and obviously works fine
<beach>
hashfunc65d: Do you understand why (+ <some-form-evaluating-to-a-list>) is not working?
<beach>
... is not semantically valid, I mean.
<hashfunc65d>
ahh! it just clicked for me. when dealing with lists and problems of this type. here's what i got: (DEFUN SHA256-+-MOD2^32 (&REST REST) (MOD (APPLY #'+ REST) (EXPT 2 32)))
<hashfunc65d>
beach: Bike: thanks all
<beach>
Pleasure.
<hashfunc65d>
Devon: thanks as well. just saw your message
<dbotton>
devon was able to get working by installing slime from github + change dists/quicklisp/installed/systems/swank.txt
<Devon>
hashfunc65d: if REST is likely to be long, REDUCE will work where APPLY won't.
<dbotton>
<slowButPresent> had to do both steps
zeroc00l0 has quit [Quit: Client closed]
<Devon>
dbotton: Which reminds me, I should (ql:update-client)
Sankalp has joined #commonlisp
<Devon>
dbotton: If (ql:update-client) says your QuickLisp is up to date, you might send in a bug report.
<dbotton>
The most up-to-date client, version 2021-02-13, is already installed.
<dbotton>
is the msg I get
<Devon>
dbotton: ... suggest that QuickLisp should use the fixed slime.
<Nilby>
i don't use slime much, but slime 2.27 and emacs 28.1 seem to work in my test environment, with ql:client-version 2021-02-13
<Nilby>
but of course emacs 28.1 made me have to re-write some elisp
<dbotton>
quicklisp installed 2.26.1
<dbotton>
that does not work
hashfunc65d has quit [Ping timeout: 250 seconds]
<dbotton>
so likely is fixed, I didn't update the dist in a long time as haven't used this mac for awhile
semz_ has joined #commonlisp
semz has quit [Ping timeout: 248 seconds]
<Devon>
dbotton: I imagine (ql:update-dist "quicklisp") would get you slime 2.27
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
<Devon>
What tool would read source code and find all probe-file calls other than testing for true/false?
Bike has quit [Quit: Connection closed]
akoana has quit [Quit: leaving]
notzmv has joined #commonlisp
slowButPresent has quit [Quit: leaving]
yauhsien has joined #commonlisp
<beach>
Do we have a maintainer for Alexandria?
<beach>
I am asking because the documentation is in need of some significant amount of work.
<jackdaniel>
yes, I think that flip214 holds the bat now
<beach>
Ah, good to know. I'll discuss it with him then.
<beach>
Currently, SICL does not depend directly on Alexandria, but it depends on several other independent libraries that do depend on it. So if SICL depends on it indirectly, we might as well depend on it directly to simplify some code. But in that case, the documentation should be accurate and complete.
<beach>
And I would like to hear from the maintainer what the plans are for the future of Alexandria.
<beach>
I personally don't much like the way Alexandria is organized. I would like to see several "modules", each with an ASDF system definition and a package definition.
<beach>
But perhaps it is then best to create a new library with the code from Alexandria (since it is likely well tested) but with a different organization, and with explicit instructions not to :USE the packages.
<mfiano>
One thing to note, is alexandria is meant for convenience over quality. And by quality, I mean both in terms of readable, well organized code, as well as algorithmic complexity.
<beach>
I don't understand. Are you saying that it is acceptable if the quality is low, as long as it is convenient to use?
<beach>
"convenience over quality"?
aartaka has joined #commonlisp
<mfiano>
I am not saying that is a good trade-off to make, no. It is just one the developers have chosen. Not long ago, I submitted a patch to ALEXANDRIA:LERP that changes the algorithm to use a numerical stable interpolation method. For a long time it was subject to numerical error. That is one example that happened to get fixed, but I also recall seeing some algorithms that were quadratic when they
<mfiano>
could be linear in time.
yauhsien has quit [Ping timeout: 260 seconds]
<beach>
I see. So then, a new library that is more concerned with quality, and so perhaps more conservative about what it contains, is perhaps the right way.
<mfiano>
I would have to comb the code to remember what is not up to (my) quality standards again, as it has been quite a while since I looked at it.
<beach>
I would also like to see some functions either explicitly state asymptotic complexity, or explicitly state that the complexity is not specified.
<mfiano>
That would be ideal, yes.
<mfiano>
I think it'd be fairly easy to create a well organized modular version of alexandria. I think it'd be far more difficult for those changes to be accepted, given the almost thoughtless dependence on that library by most projects. There is also the problem of adoption due to this fact.
<beach>
Indeed.
<beach>
Since I do not much like how Alexandria is organized, I have not considered using it as it is probably intended, i.e., as the automatic ("almost thoughtless") dependence for just about any project that needs some of the additional functionality. But if we do want a library that can be used like that, I think we have some work to do.
<mfiano>
There are 3 camps: Those that use alexandria (or serapeum and the many other utility libraries) without much thought, those that copy the functions they need into their project, perhaps with some modifications, and those that just write their own utilities from scratch. I employ all three, admittedly.
<beach>
I see. Well, wouldn't give it much thought if it weren't for this indirect dependence I mentioned. I just wouldn't use it. But now it looks like we do need a library that can be used without much thought.
<mfiano>
What are your concerns with the direct dependencies of SICL using alexandria?
yauhsien has joined #commonlisp
<beach>
Some of the things I mentioned, i.e., lack of complexity and inaccurate and incomplete documentation.
z4kz has joined #commonlisp
<beach>
One of the goals of SICL is high-quality code and documentation (we aren't there yet of course), so if we depend on something that is not up to standards, that's kind of strange.
<mfiano>
Is it a question of understanding the direct dependencies because of this level of indirection towards unacceptable code? What is the extent of alexandria usage of these libraries? Can they be done without alexandria, or can they add extensive unit tests to give some peace of mind?
<beach>
Let's see...
<beach>
For the direct dependencies, it is mostly a general feeling of unease. I am not sure there is a real problem.
<pillton>
What is wrong with fixing the documentation? Or correcting the implementation?
<beach>
pillton: Nothing is wrong with that.
<beach>
mfiano: Other libraries could certainly avoid Alexandria, but I don't necessarily control them, and I have no desire to.
<pillton>
beach: Ok.
<beach>
mfiano: A few hours ago, my thoughts were to do what everybody does and use Alexandria directly. So I started reading the documentation, and I was very disappointed.
<beach>
pillton: That is in fact what I first suggested, which is why I asked about the maintainer.
<mfiano>
This is a problem with most Lisp software unfortunately. If we had more alexandria collaborators this would be a non-issue.
<mfiano>
Everyone off doing their own thing, often reinventing wheels, doesn't help the staples mature.
<beach>
mfiano: I think I am signing up to be one, at least when it comes to indicating problems in the documentation.
<beach>
But it could also be that most people don't realize that Alexandria needs work.
Cymew has joined #commonlisp
<pillton>
mfiano: I think everyone is just swamped.
<mfiano>
phoe might be interested in this work at some point. I know he did extensive cleanup work for many other projects such as split-sequence. Sadly though, he has been pursuing other non-Lisp hobbies for a while.
<jackdaniel>
I wouldn't be surprised if most people were using alexandria for its most basic utilities like mappend, with-gensyms or random-elt; from this perspective the library doesn't need much work (if any)
<jackdaniel>
of course if these are the utilities that are demanded, then using alexandria is an overkill, but oh well
<beach>
jackdaniel: But then it needs to be split into modules so that it's clear that the dependency is just for those things.
<jackdaniel>
well, it is split into files; I personally wouldn't appreciate if I had to learn that alexandria advertises 8 systems with 16 packages
<mfiano>
If we do this in a backwards-compatible manner (with a monolithic system that depends on the modules), it probably has a good chance of being accepted.
<beach>
mfiano: That would work with several ASDF system definitions, but not with several packages.
<jackdaniel>
stylewarning made years ago a library that whisked utilities from other libraries called quickutil
<mfiano>
beach: It would if the monolithic systemn's package re-exported them into its own (the existing) package.
<jackdaniel>
but I don't think the library is maintained anymore
<beach>
mfiano: That could work.
<stylewarning>
jackdaniel: that's right, code is there, but I don't maintain it
<beach>
mfiano: Then, client code could choose whether to use one single package and one single system, the way jackdaniel prefers, or whether to use selected systems and packages.
<beach>
mfiano: Again, that might work. Client would be explicitly advised not to :USE those finer-grain packages.
<mfiano>
beach: Right. I have seen this pattern employed in some other projects for backwards-compatibility. I just tried remembering/searching for them but I had no such luck.
* mfiano
needs new RAM
<beach>
I see. No problem. I understand the basic idea.
<stylewarning>
I wish Alexandria had a BDFL
<stylewarning>
(that had good taste, of course)
<Nilby>
I really like the quickutil idea, but sometimes I think maybe lispers should just admit they can't cooperate, and try something else instead : https://plaster.tymoon.eu/view/3109#3109
<stylewarning>
Lispers can cooperate, but not just because they use Lisp, which is maybe a confusing thing :)
<stylewarning>
Common Lisp is like the open-world RPG of programming languages.
<jackdaniel>
the very fact that many systems depend on alexandria (mindlessly, for good or bad), proves that some sort of cooperation is happening
<jackdaniel>
also I don't think that it is any different (if we scale it to number people who contribute to foss) from other languages
<Nilby>
I know lispers can cooperate, as shown by many projects, but it doesn't seem to scale up to an ecosystem level
<jackdaniel>
we simply have less people, so there are less contributions
<z4kz>
is that due to the parentheses do you think?
<stylewarning>
jackdaniel: I haven't really settled on my mind if it has to do with # of people or not. I tend to think not, since other niche languages with even fewer users tend to rally around things a little better.
<jackdaniel>
of course it might be the case that people in cl ecosystem are more often smug and that would inhibit 'cooperation'
<jackdaniel>
stylewarning: right; but I don't buy reasoning behind the "lisp curse" (or whatever it is called)
<stylewarning>
oh yeah me neither
<Nilby>
i feel like it's a statistical programming personality of not compromising for whatever quality
<beach>
minion: What does BDFL stand for?
<minion>
Babacoote Deprival Firry Lepocyte
<mfiano>
z4kz: That's a bogus argument of people that see Lisp for the first time. There have been studies that have shown Blub has more brackets that an equivalent Lisp program. This is due to the fact that Lisp is a much higher level (not to be confused with less efficient) language, and so requires less code.
<stylewarning>
:))
<jackdaniel>
beach: benelovent dictator for life
<z4kz>
mfiano: =)
<jackdaniel>
(i.e what beach to sicl is)
<Nilby>
minion is so smart
<jackdaniel>
or linus to linux
<beach>
jackdaniel: Ah, right, thanks!
<jackdaniel>
sure
<jackdaniel>
Nilby: looking at the quality of a lot of software written in cl, that doesn't seem to be true;p
<jackdaniel>
perhaps "personality of not compromising <perdiod>." :)
<jackdaniel>
s/perdiod/period/
<Nilby>
jackdaniel: yes, but it's an attitude not an actuallity
<jackdaniel>
I see
<mfiano>
I think one has to realize Lisp was a research language used behind closed doors historically. It caters to exploratory programming, and is suited to single or small team researchers. I think this is both a blessing and a curse. It is often much easier to bend the language to your own thought processes than to try to understand someone else's (possibly heavy macrological (hey, I made a new
<mfiano>
word)) implementation.
<stylewarning>
mfiano: I think there are far simpler explanations
rotateq has joined #commonlisp
<mfiano>
Very likely. There have been as many explanations as users over the years. This is just my take.
<Nilby>
if a person was ammenable to compromising language quality, they would probably be using something other than CL
<stylewarning>
I train around 1 (?) person to use Lisp per month, maybe. None of this brain / thought / whatever mumbo jumbo has been supported empirically in practice. I think it really is all about barrier to entry, which has many tendrils that run deep: people, websites, documentation, unclear de facto standard libraries, etc
<stylewarning>
the reason the people i train bar none end up being good lisp programmers is not because i'm a good teacher, but because i tell them what to do and what not to do, where to look and where not to look, and i read their code and tell them what's right and what's wrong
<beach>
I would like to apologize for starting another version of this discussion. I just wanted to improve Alexandria and its documentation.
<jackdaniel>
random thought - it's all because of the fun factor. lispers pursue happines, and all projects get ugly when the complexity reaches a certain threshold (take that with a grain of salt, mkay? ;)
<stylewarning>
beach: i'm procrastinating on something else which is why i'm partaking
<jackdaniel>
I'm feeling entertained by this discussion (more so than discussing eval-when the other day ,)
<pillton>
I think we should just start focusing on the problems other languages have which don't exist in common lisp.
<Nilby>
stylewarning: you probably are a good teacher, but i mostly agree that the lisp personality stuff is mumbo jumbo, with elisp being a good example
<beach>
stylewarning: I have a suggestion. Improve the documentation of alexandria SWITCH. That would qualify as procrastinating.
<stylewarning>
pillton: lisp doesn't have enough interpersonal drama that other language communities have (:
<z4kz>
what is alexandria?
<rotateq>
I really would need some mentor again who can and wants to meet on a weekly basis in person, lack that for years. :/
<z4kz>
I'd be up for a lisp mentor
<rotateq>
z4kz: One of the heavily used utility libs.
<stylewarning>
beach: haha, i just read the doc for it, i agree, it's pretty bad
<z4kz>
ah ok
<beach>
... No explanation of the shape of a clause. Clauses are evaluated. T is evaluated. So is OTHERWISE (hint, it has no value). No explanation what TEST and KEY do.
<rotateq>
z4kz: Named after the nice library of Alexandria. :)
<z4kz>
I need to get through practical common lisp first though.
<beach>
... Parameter named OBJECT?
<mfiano>
z4kz: I would be happy to help.
<z4kz>
mfiano: cool
<beach>
Me too.
<z4kz>
thanks
<mfiano>
You can PM me anytime.
<beach>
I prefer discussions in public.
<stylewarning>
rotateq / z4kz: I don't have infinite time but I've made time to talk to random internet people about their lisp projects for around an hour a week on Zoom/whatever--- screenshare, pair program, co-review code
<rotateq>
z4kz: With some questions I can help by now from time to time too. Or I see where I have to go on myself digging deeper.
<stylewarning>
i've made time (consistently)**
<z4kz>
ah nice, thanks
<rotateq>
stylewarning: Heh, it was not meant soo directly, now it's cool to read you again here. :)
<rotateq>
Your talk from 2013 about maths with Lisp is still very nice. ^^ and others of course, I know I never could work at Rigetti or another such company but try my best :)
<stylewarning>
idk why people think that
<stylewarning>
i've hired a high school drop out before with no experience
<jackdaniel>
the hardest thing with working with rigetti was the paperwork, and it wasn't above "standard" when dealing with companies as a vendor ,)
<stylewarning>
yeah, Rig could have been a little better w that stuff
<Nilby>
alexandria comes in around 19-20 % exported symbols without docstrings
<z4kz>
what do you mean by 'utilities' re alexandria?
<rotateq>
stylewarning: I have some physics/math background and interest too but all would need much effort. :)
<rotateq>
Nilby: Oh.
<stylewarning>
rotateq: at my current employer, my biggest hiring issue isn't skill level, it's that i'm limited to citizens and residents of the USA, which unfortunately casts a shadow on so much of the talented world
<rotateq>
Yes there are many smart people out there not yet discovered.
<rotateq>
I'm far away, from Germany. :)
<jackdaniel>
since things slided to the topic of work, I'll better get going to get some of it done. see you later \o
<rotateq>
We're just about to have a little mock exam on networks. The next two modules will be more interesting again.
treflip has joined #commonlisp
<rotateq>
z4kz: In which chapter are you now?
xaotuk has joined #commonlisp
ttree has quit [Ping timeout: 256 seconds]
WBarends has joined #commonlisp
amk has quit [Ping timeout: 260 seconds]
amk has joined #commonlisp
<z4kz>
rotateq: I'm actually going to read this book LISP a gentle introduction to symbolic computation by touretzky tonight
<z4kz>
I want to get an overview of key ideas first
<z4kz>
then I'll dive into PCL
<rotateq>
Okay I hope things will work out then, you will benefit from a good basis forever and also for many other things.
<z4kz>
thanks
random-nick has joined #commonlisp
xaotuk has quit [Ping timeout: 248 seconds]
aartaka has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
analogsalad has joined #commonlisp
yauhsien has quit [Ping timeout: 276 seconds]
shka has joined #commonlisp
cage has joined #commonlisp
kevingal has joined #commonlisp
azimut has quit [Ping timeout: 240 seconds]
kevingal has quit [Ping timeout: 250 seconds]
kevingal has joined #commonlisp
Dynom has joined #commonlisp
thunderstruck has quit [Quit: Leaving]
matt` has joined #commonlisp
perrierjouet has joined #commonlisp
lonjil has quit [Remote host closed the connection]
lonjil has joined #commonlisp
attila_lendvai has quit [Ping timeout: 246 seconds]
matt` has quit [Ping timeout: 260 seconds]
yauhsien has joined #commonlisp
jmdaemon has quit [Ping timeout: 248 seconds]
analogsalad has quit [Quit: bye]
<beach>
So when the Alexandria documentation says "<mumble> must be a proper sequence", what does it mean if <mumble> is *not* a proper sequence? Is it undefined behavior? Is an error signaled? Should an error be signaled? Something else?
<beach>
I don't see the Common Lisp HyperSpec define the phrase "x must be y".
<beach>
But maybe I just didn't look in the right place.
frgo has joined #commonlisp
frgo has quit [Read error: Connection reset by peer]
frgo has joined #commonlisp
<mfiano>
I wouldn't expect every library's documentation to use formal standard vocabulary, and assume the user can M-. to see how it behaves. No amount of natural language can fully describe the behavior of code, after all, and code doesn't lie.
<beach>
Your expectations are way lower than mine then.
<mfiano>
I'm just a realist, but that is a fine opinion as well.
<jackdaniel>
they should have said that "x is y", then when someone invokes the function with x that is not y, a condition dont-defy-the-reality could be signaled ,)
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
xaotuk has joined #commonlisp
yauhsien has quit [Ping timeout: 248 seconds]
karlosz has joined #commonlisp
ebrasca has joined #commonlisp
aartaka has quit [Ping timeout: 276 seconds]
aartaka has joined #commonlisp
karlosz has quit [Ping timeout: 248 seconds]
Algernon69 has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
z4kz has quit [Quit: Client closed]
cage has quit [Ping timeout: 276 seconds]
cage has joined #commonlisp
aartaka has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
semz_ is now known as semz
igemnace has joined #commonlisp
analogsalad has joined #commonlisp
treflip has quit [Quit: Quit]
yauhsien has joined #commonlisp
Algernon69 has quit [Quit: Leaving]
yauhsien has quit [Ping timeout: 256 seconds]
z4kz has joined #commonlisp
analogsalad has quit [Quit: bye]
Devon has quit [Ping timeout: 276 seconds]
waleee has joined #commonlisp
zacque has quit [Quit: Goodbye :D]
frgo has quit [Ping timeout: 248 seconds]
szkl has joined #commonlisp
pillton has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
heisig has joined #commonlisp
tyson2 has joined #commonlisp
OlCe has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 276 seconds]
OlCe has joined #commonlisp
z4kz has quit [Quit: Client closed]
unixlisp has joined #commonlisp
slowButPresent has joined #commonlisp
dec0d3r has quit [Quit: Leaving]
Bike has joined #commonlisp
frgo has joined #commonlisp
lisp123 has joined #commonlisp
frgo has quit [Remote host closed the connection]
leeb has joined #commonlisp
<lisp123>
i think the issue with CL is that its not backed by a major platform
<lisp123>
Swift / Objc --> Apple | Python, Java --> Google | JS --> Browsers | C/C++ --> General Powerhouses
xaotuk has quit [Ping timeout: 260 seconds]
<pranavats>
lisp123: What's the context? Some might find its independence from any single powerful interest group appealing.
<beach>
pranavats: A long discussion almost 12 hours ago.
<beach>
pranavats: You had better check the logs.
<beach>
... if you are interested. It is not that interesting actually.
<pranavats>
Okay. Thanks.
<rotateq>
lisp123: And that's a good thing.
waleee has quit [Quit: WeeChat 3.5]
rgherdt has quit [Remote host closed the connection]
<seok->
Issue? CL has an issue?
<beach>
No, I think the conclusion was that there are no issues.
<lisp123>
issue is a wrong word
<lisp123>
but i see nothing in lisp that prevents it from being as popular as other languages, but in any case I'm more than happy as it is :) to rotateq 's point
<rotateq>
Do we need being overhyped? :) And as big as some company can be, it can be nothing from one day to another.
<lisp123>
the _only_ potential benefit is more jobs in lisp
<yitzi>
lisp123: I think you assuming learning lisp is the same level of difficulty as all other languages. In my opinion CL is a very advanced, powerful and expressive language. Which basically precludes it from being popular. Most of the popular languages are the exact opposite: basic, weak and restrictive. Just my opinion.
splatt990 has joined #commonlisp
<lisp123>
yitzi: I agree to a degree with that viewpoint, but I wonder if thats partly with how programming has been taught (a lot of potentially bad habits / unclear concepts in other languages)
<lisp123>
Also I find the difficulty with lisp _may_ be in how simple its semantics are --> instead of churning out boilerplate, it forces one to think more deeply at an earlier stage
<lisp123>
Which comes back to your point to a large degree, if you numb people down with boilerplate, they don't have time to come up with cleaner, abstract code and just pump in basic pseudocode
szkl has quit [Quit: Connection closed for inactivity]
<yitzi>
Since I am self taught, I cannot comment on the relation of any education system to the quality of programmers. In my own disciplines (Math/Physics) the quality of the education system is not purely responsible for a relative dearth of students. The main reason is that they are just intellectually difficult disciplines.
rotateq has quit [Remote host closed the connection]
<beach>
We (me and my favorite coauthor mainly) taught Common Lisp for around 15 years to third-year undergraduates, with some success.
<beach>
The ones who wanted to get it did. The others hated it because it did not resemble anything they had learned before, and because they didn't think it would be useful to them I guess.
<beach>
And I don't think the success rate was any lower than that of most courses we taught, i.e., around 20% or so.
kevingal has quit [Ping timeout: 256 seconds]
<beach>
So yes, a large part of the problem is that we crank out masters-level graduates with knowledge only in fairly traditional programming languages and programming techniques.
<beach>
My favorite coauthor is considering teaching it again, but then the problem is that there are almost no colleagues qualified to do the lab classes.
<beach>
And there are just too many students for one person to do it alone.
<seok->
Well I guess
<seok->
lisp123 has a point that there's not much financial motivation for students to learn CL
<seok->
I mean most of them want to be working for a company
unixlisp has quit [Quit: Client closed]
<tychoish>
overrated.
<beach>
I don't think that's the problem. Most students here have no idea what to expect when they get a job. It was a problem when we taught it at the engineering school because they are highly career oriented. But at the university, they really don't know.
kevingal has joined #commonlisp
<seok->
Talking about engineers, what about all those CAD users, they have a need for lisp
<beach>
The university students really just want a degree with as little effort as possible, and Common Lisp seemed like a lot of effort when they thought they already know everything they would ever need.
waleee has joined #commonlisp
<dlowe>
amusingly CL is alive and well in psychology labs
<pranavats>
I rather like that most CL programmers I encounter have internal motivation to do it. External motivations often last only as long as the stimulus motivating them.
<seok->
wait what? What are they doing with CL in psychology?
<dlowe>
early work was done in CL (due to its AI reputation probably), so you have to learn CL in order to read the papers
<dlowe>
and they're not programmers, and they'll be damned if they have to learn another language
<beach>
Interesting!
<dlowe>
so they write really, really terrible CL
<dlowe>
I learned CL as part of a skills acquisition lab. They had a cognitive model (that was a Hopkins NN but they didn't know that)
<pranavats>
seok-: See ACT-R, a theory in Cognitive Science. It is still being actively developed in CL.
<seok->
Would you have any links to these works in psychology using CL dlowe?
<seok->
Ah thank you
<pranavats>
It's implementation, I mean.
<dlowe>
they needed their thing that took two hours to run to run in less than a second
<dlowe>
and it was such terrible code that it wasn't even that hard
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
<seok->
If you ask me, CL is kind of a gold mine for those who want a job also
<seok->
Nobody knows how to write CL
<lagash>
As in, job seurity once you have a job..?
<Shinmera>
I can help with the job problem if people give me more money to spend on Lisp programmers :)
<seok->
I don't know, maybe approach some companies that are using CL codebase
<seok->
I assume a lot of them don't even look because they're sure they are not going to get applicants
<Shinmera>
Speaking of that, there'll be a Kickstarter for Kandria launching in June, so pretty soon! If you want to pitch in, check it out: https://kandria.com/kickstarter
<dlowe>
Shinmera: I've been following on Fedi :)
<Shinmera>
Ah, I should post more on masto
<dlowe>
maybe have an official company account?
<Shinmera>
I've already no energy to manage the socials I do have :(
<dlowe>
it's billable marketing hours
<Shinmera>
Note I said energy, not time.
<Shinmera>
Anyway, don't want things to veer too far off topic.
pve has joined #commonlisp
frgo has joined #commonlisp
<lisp123>
the more median programmers come to CL, the more bad frameworks / libraries and the higher signal to noise
xaltsc has quit [Read error: Connection reset by peer]
<Shinmera>
ah man who cares. We already have an overflow of libraries. It doesn't matter. What matters is that the more people we get in, the more likely we'll get people that improve existing solutions, too.
<Shinmera>
The kinda elitism about "oh *those* people aren't good enough" is not helping anyone.
<contrapunctus>
Did someone mention a CL job?
* contrapunctus
will join in a heartbeat
frgo has quit [Ping timeout: 248 seconds]
<Shinmera>
ravenpack is hiring still, afaiu.
<lisp123>
Shinmera: True
<Shinmera>
I would like to be hiring, but do not have the funds to do so except to offer bounties for very select things I need (which I am doing already).
<seok->
Someone should pay you for all the libraries you've written shinmera
MetaYan has quit [Read error: Connection reset by peer]
<tychoish>
also building really ergonomic tools to do the things that make existing shops be able to do a little thing with CL (e.g. more support/connections to databases, stream processing tools, and gRPC stuff) will mean that CL can do the land-and-expand thing and not depend on companies making their entire play "use CL"
frgo has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
<lisp123>
Shinmera: One thought is to open up 'volunteer' positions
<lisp123>
and maybe with backpay if the project is a success
<Shinmera>
I vehemently object to hired work that does not pay.
<tychoish>
^ this
<tychoish>
there's so much code that needs to be written and people with money who would be willing to pay for it.
<Shinmera>
The games industry is already bad enough at exploiting peopel's passion for profit. I don't want to add to that.
<Shinmera>
That said, if someone wants to do stuff because they feel like it, Trial and all supporting libraries are open source.
<lisp123>
Fair enough. I think you may find a few people (maybe 1 or 2) who would be keen to work on a project as a volunteer, and if you set a condition to agree to pay them X if the project is successful, I wouldn't feel too bad
<seok->
I don't think game industry pays much attention to how their game is coded
<lisp123>
Esp if they are allowed to take their code and use it as part of the resume for future jobs
<seok->
I don't see big game titles using sophisticated architectures well thought out
<lisp123>
Biger problem ofc is without paid work, people tend to disappear after the initial excitement
<lisp123>
Which is why we have so many grand ideas to improve lisp, but things move alot more slowly than our imaginations ;)
<Shinmera>
lisp123: I would only agree to such a thing if the person in question was a co-founder of the company. But I deem it very unlikely that I would find someone willing to go that far.
<lisp123>
Shinmera: Agree
n1to has joined #commonlisp
n1to has quit [Remote host closed the connection]
rotateq has joined #commonlisp
<seok->
On another one, is anyone currently working on blockchain with CL?
<tychoish>
sort of
n1to has joined #commonlisp
<tychoish>
(not actually writing CL, but doing stuff.)
rgherdt has joined #commonlisp
kevingal has quit [Ping timeout: 248 seconds]
<seok->
what are you working on?
<tychoish>
cosmos/tendermint
Lycurgus has joined #commonlisp
<tychoish>
all of the stuff that people do is accessible via gRPC and a lot of stuff is WASM-able so like, it wouldn't be too hard (in theory, of course) to write/ship CL code to do things (including some easy tooling things,) but
<Lycurgus>
the mention of blockchain struck me as metaphorical flatulence
<tychoish>
I mean, I come from a database background, and like statemachines are cool, a lot of what people are doing with them are... marginally grounded in practical use cases, but there is some stuff that I think has some merit, and I think building things that are more useful is definitely a thing that would help.
<tychoish>
anyway, feel free to chat with me out of band, I don't want to take up space here, as it's somewhat orthogonal, but I think the higher level of my point is "the thing that stops CL (or anything) from getting adoption in areas like this is support for interrop around the edges (e.g. in our case gRPC and wasam)"
<dlowe>
pretty sure there's gRPC support in CL
guest74 has joined #commonlisp
ec has joined #commonlisp
ec has quit [Client Quit]
ec has joined #commonlisp
<tychoish>
there is, there isn't TLS support (which is a big caveat) and limited async support (which is a very small caveat.)
Cymew has quit [Ping timeout: 256 seconds]
<lisp123>
Async is pretty awesome though :)
<dlowe>
yeah, that's a pretty severe limitation
<dlowe>
async is tough without deep runtime support
kevingal has joined #commonlisp
<tychoish>
async is great, and I can't see why we wouldn't be able to have _some_ kind of async operation, I think it's just less off an issue than the other, because you can fake it on the client (or server) with threads if you need to, and you often don't need to?
<tychoish>
whereas not having TLS is often a hard barrier to adoption before you really get started
<Bike>
does TLS mean thread local storage here, or transport layer security, or something else?
<dlowe>
transport layer security
<Bike>
ah k
<dlowe>
sorry, I meant TLS is a severe limitation
<lisp123>
TLS --> nginx reverse proxy ;)
heisig has quit [Ping timeout: 250 seconds]
kpoeck has joined #commonlisp
ec has quit [Quit: ec]
ec has joined #commonlisp
ec has quit [Ping timeout: 240 seconds]
treflip has joined #commonlisp
<dbotton>
"the more median programmers come to CL, the more bad frameworks / libraries and the higher signal to noise" list123 - The vast majority of what a master writes in is life is "subpar" in fact the only way to be sure to get one good library is to have written hundreds of bad ones
<White_Flame>
I think it's more an issue of ecosystem expectations osmosing into CL
<dbotton>
the vast majority of any huge library of code is garbage, what is worthwhile floats to the top, the rest gets to make the numbers look better for everyone
<White_Flame>
the ecosystems out there rely on cobbled together hacks, and that becomes familiar to many programmers
<dbotton>
people just want to see big numbers
<dbotton>
most won't use any of it
<dbotton>
so bring on the garbage
<White_Flame>
and there's very little pushback to bad infrastructure from those other languages, and just accept them
<dbotton>
and highlight the good
<dbotton>
so just make a point of emphasizing what is worth using all the time
rgherdt has quit [Ping timeout: 276 seconds]
ec has joined #commonlisp
<White_Flame>
dbotton: there's a big problem with that, though, in that experienced people or those who work with more complex problems have different definitions of what's "worth using"
<White_Flame>
for people whose majority of coding is instantiating and connecting framework-provided tools, there's little notion of need of anything well-engineered
<White_Flame>
and their perspective of what is acceptible design vastly differs from others
<lisp123>
dbotton: I would recall my earlier comment, I was just thinking out loud and don't have a strong leaning towards that anymore. A better way to rephrase is - everything I need in CL already exists, so I don't care about its popularity
<dbotton>
correct worth using is often missing the "rest of the story"
<dbotton>
worth using for what project
<dbotton>
may things are over specified for the need
<White_Flame>
for example, metaprogramming is hugely important to me, and most other languages/ecosystems leave programmers with no notion of it at all (or appropriate the term poorly)
<dbotton>
lisp123 I agree
<guest74>
mfiano: I agree with you. I think lisp is a language that you can bend to your will, and not bend to its. You can see people's personalities and thoughts in their code. It's even more apparent in things like AoC. So it's less about finding someone that programs lisp, but who thinks the same too.
<dbotton>
CL fits my needs (and most peoples needs)
<dbotton>
(they just don't know it yet ;) )
<White_Flame>
dbotton: exactly
<guest74>
Of course, this doesn't disqualify cogs in a machine programming, which is probably what we need more of. Bring on the grunts.
<dbotton>
I am going to do my best to get people to"know it"
<White_Flame>
in order for people to know that, they need to have a need for its strengths
<dbotton>
'cause I CL can help people reach another level in programming
<White_Flame>
if what they're coding never needs more than what they already have, it's moot
<dbotton>
unless I give them an excuse
<dbotton>
so CLOG ;)
<tychoish>
lisp123: grpc really wants to terminate ssl at it's endpoints (and use it for client auth, for example,) using nginx to terminate SSL/TLS for grpc often doesn't work in practice.
<dbotton>
If I wanted fame and fortune I could have done in Python years ago
<dbotton>
I want to help people become better programmers
<guest74>
dbotton: do you work on a mac?
<dbotton>
I still feel that knowing Ada and Lisp are the key
<dbotton>
I work on many platforms
<guest74>
I'm looking for an easy environment for a mac person.
<dbotton>
Lately I have been using straight Win64, but feeling mac'is
tyson2 has quit [Remote host closed the connection]
<White_Flame>
for me, I think asm, forth, and lisp are proper coverage of getting computers to do things. then add prolog to the mix to get out of imperative thinking
<dbotton>
then add a symbolic link or alias to the executable
<dbotton>
run it from the command line
<lisp123>
yeah emacs on mac is very smooth
<tychoish>
I've definitely done most of my programming in professional situations, and think that (in general) people really like writing software that other people are going to use (which is why I sort of skew towards potentially (quasi?) industrial applications, and being able to sort of increase relevance based on that.)
<dbotton>
tychoish - that is why we need more mediocre programmers using CL
<tychoish>
I'm 100% into it :D
<dbotton>
and help then teach them to be great programmers
<tychoish>
also the thing I really like about making software, in addition to shipping things that people actually use, is being able to work with other people on said software (and making them better programmers, and becoming a better programmer)
<dbotton>
CL so far is not real good at that
<tychoish>
so while like "oh we need more plumbing" is kind of uninspiring as a goal, I think it's important.
<dbotton>
there is like zero tutorials on how to do team programming with CL
<dbotton>
Ada is designed from start for teams
<White_Flame>
tychoish: yeah, that's similar to a basic mantra of coding: "Always have a running version". It keeps satisfaction high
<dbotton>
it is on my list of things to do
<tychoish>
well, ada is designed for like missile defense systems
<dbotton>
medical, business etc
<lisp123>
hmmm i think the quality of lisp materials is exemplary - and one can learn to be a very good programmer from them, BUT it requires self study
<dbotton>
lisp123 yes - but what we need are things to teach people to work as a group
<White_Flame>
I think learning to be a very good programmer is orthogonal to what you learn from those books
<dbotton>
lisp is not inherently good at planning and executing anyhting
<tychoish>
I think you gotta work on things with other people and learn to write good tests and stuff.
<dbotton>
no "specs"
<White_Flame>
I'd say the ability to see the need for abstractions, and to be able to create them well, are the most important facilities to grow, and that's rarely touched upon
<lisp123>
fair enough (i don't even test lol, if it compiles without warning its good to go)
<tychoish>
that's terrifying
<dbotton>
or in the lang here - protocols are poorly defined and there is poor means to do it
<dbotton>
in Ada if something compiles it will work
<tychoish>
anyway, I think it's less about libraries in general and more "libraries around the edges," lisp is kidna great once everything's in lisp, and a kind of a nightmare if you want to get data into our out of it (and into some other kind of system)
<dbotton>
white_fame - bingo
<lisp123>
dbotton: CL has poor protocols?
<dbotton>
poor means to produce interfaces between modules
<lisp123>
CLOS (and CLIM for an example of how its done)
<dbotton>
and that is half baked
kevingal has quit [Ping timeout: 246 seconds]
<dbotton>
the fact that a function symbol name is all that one can specify, can't compile the specs separate etc
<dbotton>
but that is not a show stopper
kevingal has joined #commonlisp
<dbotton>
the rapid dev cycles lisp uses are a win if everyone is an expert
<dbotton>
and communication is in a single room
<tychoish>
I think this idea that the compiler should save you from everything or that you can have a compiler should be able to enforce all the constraints, always feels incomplete. like software without side effects doens't do anything, and compilers which try to do too much, are just slow and difficult to work with. so there's always a trade off there, and writing tests makes you have to actually think about how your APIs are used, and that's
<tychoish>
*useful*
<dbotton>
agreed
<White_Flame>
dbotton: I'm not talking abotu interfacing between modules, I'm talking about creating new abstractions
<dbotton>
ok
lisp123 has quit [Remote host closed the connection]
<White_Flame>
whether it's just creating better function protocols, or creating new DSLs and build tools, an abstracting mind shouldn't ever be constrained to a single perspective of tooling
<dbotton>
but the idea is documenting wat is needed for those abstractions
<White_Flame>
yes, documentatin is part of actual software engineering
<dbotton>
and the current way of protocols doesn't capture enough
<White_Flame>
programming languages are just one layer of tools, built by someone, and building better tools in both the small and large is how we advance overall
rgherdt has joined #commonlisp
<dbotton>
either way, my point is that team programming in CL is not a built in
<White_Flame>
the ability to see the need for a new tool, however, seems to be limited. once one learns a tool, the easy route is to see how it's applicable to everythign
<dbotton>
and there needs to be documentation and tools for it
<tychoish>
agreed
<White_Flame>
how is team programming built into other languages?
<dbotton>
look at the way Ada does it
<dbotton>
Specs that are compiled
<dbotton>
tools for design
<dbotton>
etc
<dbotton>
it is not in the culture of CL either
<dbotton>
and not sure that it should be
<White_Flame>
while I'm not very familiar with Ada, haskell has similar claims re its type-first development perspective and compiler support
<dbotton>
the question is how to make it happen and keep the fast paced system of chage
<dbotton>
change
<White_Flame>
and similar "if it compiles, it will work" claims that do not cover a whole host of bugs
<White_Flame>
what you are getting at is not a technical problem
<White_Flame>
it's one of necessary community scale
<White_Flame>
there were far more tools back in lisp's commercial heyday, too
<White_Flame>
all wrapped up in proprietary lisp OSes
<White_Flame>
of course, the conglomeration of language branches into Common Lisp was the core language itself, as everyone had their own tooling
<White_Flame>
it's a large and non-CL-standard effort to get that sort of things back into the CL community
<White_Flame>
and people worship emacs, which isn't even an IDE in the commonly thought of sense, locking people in a "good enough" state of tooling :-P
<White_Flame>
(come at me, bro)
<White_Flame>
SLIME is great for interactivity, but it doesn't reach much into actual project management at all
<guest74>
anyways, all communities go through stages. We haven't finished the library wars yet.
<dbotton>
White_Flame agreed
<dbotton>
you think you could put what is needed in a doc we could all work from?
<dbotton>
a place where something we can target
<White_Flame>
I don't think it's useful because there's too diversified opinions of what should be worked on
<dbotton>
I am not saying that this creates one tool
<White_Flame>
commercial efforts do focus people, but then also pull stuff away from community use
<dbotton>
I am saying that it creates a focused goal and the tools win
<dbotton>
best tutorials wen
<dbotton>
etc
<White_Flame>
and it was only durring the commercial lisp days that this sort of stuff really advanced
<dbotton>
but at least a doc giving direction
<dbotton>
well I am willing to add my part and others will
<White_Flame>
yep, at some point I will coalesce a well-edited rant :-P
<White_Flame>
and post it somewher
<dbotton>
exactly
<guest74>
I think part of the answer lies in making a generic infrastructure of 'missing' components. A set of reserved namespaces(packages) that can contain all the necessary stuff to deal with those namespaces.
<dbotton>
na, just a list of stuff cool to exist
<dbotton>
for helping people program together
<dbotton>
who want to
ttree has joined #commonlisp
<guest74>
It would help everybody to program together if we had a common language for all the missing bits.
Lycurgus has quit [Quit: Exeunt]
<dbotton>
maybe but I am looking to target an unruly crowd of highly opiniated people us
<guest74>
yes, but in the generic interface you only stick the bits everybody agrees are needed. Sort of how common lisp came about.
<dlowe>
If you want a full CL system, you can just use hu.dwim
aartaka has quit [Ping timeout: 256 seconds]
<dbotton>
I will take a look later
aartaka has joined #commonlisp
<dbotton>
but I am looking for an exchange of ideas for things that would help teams work as a team with CL
<dbotton>
process
<guest74>
multi-user repl?
<dbotton>
if a particular tool works for that process great
<seok->
oh god
<seok->
multi-user repl? how would that even work
<dbotton>
seems easy enough a few remotes to one lisp image
<dbotton>
but that may or may not be the way
<guest74>
you each share some space on a 'whiteboard'
<seok->
so just routing expressions to one system?
<dbotton>
all the above
<dbotton>
see the idea is all of these ideas recorded some place
<dbotton>
and also how do you develop abstractions in CL in an organic way in a group
<dbotton>
individually CL is exactly how I always developed software
<dbotton>
even though I never used CL before a year or so a go
<dbotton>
probably because I started years ago with basic on a trs-80 :)
<seok->
It's not just lisp specific but I think a flowchart/node graph generator for visually representing function, symbol and import dependencies would be beneficial for individuals or groups looking at a codebase
<guest74>
that 2k limit was a bummer.
<dbotton>
lol it may be learn assembly at 9
<dbotton>
main me
<White_Flame>
you develop abastractions in a group by constant communication, and holding off implementing new ideas until they've percolated through thoughtful people for a period of time to the point where it's bonked against raised issues, solutions arose, and it settled into established confidence
<dbotton>
maid be (sorry fingers not working so well today)
<guest74>
lol
<dbotton>
(had a stroke really that way for me :( )
morganw has joined #commonlisp
<dbotton>
white_flame - true but are there other ways
<dbotton>
more rapid fire like lisp with one person
<White_Flame>
sure, other less optimal ways ;)
<guest74>
I envision a system that is less about text files stored in a repository and more a collection of interchangeable annotated functions/packages.
<dbotton>
that is what needs exploring and what tools would support it
<White_Flame>
the time cost of prototyping & refactoring need to be taken into account. If it's a familiarized problem with uncertain solutions, the time needs to be spent in consideration
<dbotton>
for many parts of a system that are critical, maybe multiple attempts to implement and then compare
<White_Flame>
compare what? the point of abstraction is to make things more easily manageabble in the large
<guest74>
yes, I'm thinking even ability to benchmark and compare aspects of a system
<dbotton>
I often do that on my own even
<White_Flame>
so the only real world measurement is to use it in the large, which is a heavyweight investment
<dbotton>
see how each approach works
<guest74>
A collection of SORTs that you can peruse and choose from for your situation.
<dbotton>
that is low level but in a sense yes
<dbotton>
well brainstorming is always with out constraints
tyson2 has joined #commonlisp
<guest74>
I've wondered how much space would be wasted/gained by storing a system where each individual function is versioned.
<dbotton>
not much
<dbotton>
COM/DCOM is like that
<dbotton>
at least the interfaces are versioned
<dbotton>
My take away for myself from this - list the things that would make CL teams productive, in person and remotely, and tools needed. This is at each stage: 1. finding the problems to solve 2. abstractions that conform to the problems 3. implementations 4. testing 5. error corrections
<dbotton>
there is some existing literature mostly from Paul Graham's discussions about his success
<guest74>
anyways, since it's cl and nobody usually agrees 100% on a direction, I just slowly write generic systems as I use them. usually in a manner that would anger most people. So all my generic stuff about a font lives in the package font:
<dbotton>
that is just syntax
<guest74>
it's a protocol.
<dbotton>
for example Graham's approach is that each group owns their piece
<guest74>
i think protocols should be easy to find/discern and intuitive.
<dbotton>
what you put it your bag is your problem
<dbotton>
in todays world COM was a very good idea - a binary interface
<dbotton>
just is too heavy
<dbotton>
and was hampered by money and M$
<dbotton>
but the idea that any part - any language - any platform
<dbotton>
is not a body thing
<dbotton>
sorry I know I am rambling a bit
<guest74>
I just think generic interfaces for things, populated with a bunch of interchangeable documented algorithms would be good for learning and as scaffolding for building ideas, instead of worrying about building tools.
<dbotton>
that is how most everyone develops
waleee has quit [Ping timeout: 260 seconds]
<dbotton>
I make a point to never develop algorithms until absolutely needed for optimization
<dbotton>
only a fool develops a sort algorithm before knowing if what exist is not fast enough
<dbotton>
(which today it almost always is fast enough)
<dbotton>
"components" are always first choice
waleee has joined #commonlisp
<dbotton>
I have not published yet full docs on wrapping existing components yet for CLOG or did any major examples, but is the key to it
<dbotton>
for example the lisp IDE example
<dbotton>
that uses the ACE Editor
<dbotton>
I have to finish this side track (web sites...) which I am on
<dbotton>
almost done with db based content and blogs
<dbotton>
and then will work on wrapping a library for charting
<dirtcastle>
best lisp shell? best lisp for scripting? an alternative to bash , sh etc?
<ehammarstrom>
What's a common or "best practice" way to write a parser (for a blub language) in CL? In Haskell you'd perhaps write a parser combinator, what's the lispy way?
<random-nick>
ehammarstrom: maybe some parser generator library like esrap
Oladon has joined #commonlisp
aartaka has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
vats has joined #commonlisp
<ehammarstrom>
random-nick: looks neat, thanks
guest74 has quit [Quit: Connection closed]
tyson2 has quit [Remote host closed the connection]
kevingal has quit [Remote host closed the connection]
waleee has quit [Ping timeout: 256 seconds]
Devon has joined #commonlisp
azimut has joined #commonlisp
<White_Flame>
ehammarstrom: for an existing blub language with all their weird edge cases, or for some new basic language?
dirtcastle has quit [Ping timeout: 250 seconds]
tfeb has joined #commonlisp
<dlowe>
there's parser combinator libaries for CL
<yottabyte>
someone explained the difference between parallel and concurrent when talking about let, but I don't remember. because let is parallel, but not concurrent. can someone explain it again?
<dlowe>
but most compilers I'm aware of use recursive descent instead of tables or frameworks
tfeb has quit [Remote host closed the connection]
<dlowe>
yottabyte: parallel binding, not execution
<dlowe>
yottabyte: it's an unfortunate coincidence of terms
notzmv has quit [Ping timeout: 248 seconds]
<Bike>
yottabyte: the values are evaluated in an environment in which none of the variables are bound, so we sometimes say the variables are all bound "in parallel". but the evaluations take place sequentially, so it's not "concurrent". the meaning of "parallel" in the context of LET is totally unrelated to concurrency in the sense of multithreading etc.
<Bike>
and it is kind of confusing indeed
tyson2 has joined #commonlisp
<yottabyte>
I see
kpoeck has quit [Ping timeout: 252 seconds]
tfeb has joined #commonlisp
dirtcastle has joined #commonlisp
jmdaemon has joined #commonlisp
tfeb has quit [Ping timeout: 276 seconds]
jeosol has joined #commonlisp
Devon has quit [Read error: Connection reset by peer]
shka has quit [Ping timeout: 248 seconds]
waleee has joined #commonlisp
<White_Flame>
yottabyte: (let ((a expr1) (b expr2)) ...) is directly analogous to ((lambda (a b) ....) expr1 expr2) in terms of when the exprs are evaluated, and when A & B come into existence
<dlowe>
(let* ((a expr1) (b expr2)) ...) is analogous to (let ((a expr1)) (let ((b expr2)) ...)) in the same way
treflip has quit [Quit: goodnight]
Oladon has quit [Quit: Leaving.]
karlosz has joined #commonlisp
<yottabyte>
thanks all
ec has quit [Quit: ec]
karlosz has quit [Ping timeout: 260 seconds]
zmyrgel has joined #commonlisp
Oladon has joined #commonlisp
zmyrgel has quit [Remote host closed the connection]
notzmv has joined #commonlisp
akoana has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
tyson2 has quit [Remote host closed the connection]
ebrasca has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 248 seconds]
hexfive has joined #commonlisp
hashfunc65d has joined #commonlisp
Oladon has quit [Quit: Leaving.]
Dynom has quit [Quit: WeeChat 3.5]
materialfuture has quit [Ping timeout: 246 seconds]
ccregor has joined #commonlisp
gaqwas has joined #commonlisp
ebrasca has joined #commonlisp
wildlander has joined #commonlisp
igemnace has quit [Ping timeout: 246 seconds]
tyson2 has joined #commonlisp
hexfive has quit [Quit: WeeChat 3.5]
causal has joined #commonlisp
causal has quit [Client Quit]
heisig has joined #commonlisp
causal has joined #commonlisp
guest74 has joined #commonlisp
causal has quit [Client Quit]
causal has joined #commonlisp
causal has quit [Client Quit]
causal has joined #commonlisp
heisig has quit [Quit: Leaving]
causal has quit [Client Quit]
causal has joined #commonlisp
causal has quit [Client Quit]
causal has joined #commonlisp
causal has quit [Client Quit]
causal has joined #commonlisp
causal has quit [Client Quit]
causal has joined #commonlisp
abrantesasf has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
Bike has quit [Quit: Connection closed]
abrantesasf has quit [Remote host closed the connection]
pve has quit [Quit: leaving]
random-nick has quit [Ping timeout: 256 seconds]
analogsalad has joined #commonlisp
igemnace has joined #commonlisp
dmh has joined #commonlisp
analogsalad has quit [Client Quit]
akoana has quit [Quit: leaving]
Bike has joined #commonlisp
causal has quit [Quit: WeeChat 3.5]
causal has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Read error: Connection reset by peer]
n1to has quit [Quit: Leaving]
lisp123 has joined #commonlisp
<lisp123>
I just learned codemirror is written by a Lisp Hacker
<lisp123>
and its documentation / code seems top notch...not suprised ;) Definitely the option to go for for anyone looking to implement editors in the browser