<hashfunc1c8d>
how is (< #xC835BEBB969CC1F41AD72A0427301452F19CC9DBFCB3EEDDF4694B640D18635C8A4FADEF2DD5C473FBF62160243BF428B6C670F680C3A7064F2C28B97FEA663882B5E5827B3DB4551AC11D8202631E6163E2C3491AD8871F1129476BACFFA/5184A1AAF8A317C77CB5F52F28E46D41C3DBB19E3F9D6D5A1C6FC552107455670DCB455049E2F72F93E038F67A2CCCFD0CAFB84A3F596DF02B0A9F305F0511 #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F) => T
<hashfunc1c8d>
?
<hashfunc1c8d>
am i missing something?
<Bike>
there's a / in there
<Bike>
the first number is around 1.7d76, and the second around 1.2d77
<beach>
Good catch!
<hashfunc1c8d>
Bike: ah! thanks, i totally missed that
semz_ has joined #commonlisp
s-liao has quit [Ping timeout: 250 seconds]
semz has quit [Ping timeout: 248 seconds]
zacque has joined #commonlisp
yauhsien has joined #commonlisp
s-liao has joined #commonlisp
Bike has quit [Quit: Connection closed]
zeroc00l0 has quit [Ping timeout: 250 seconds]
zeroc00l0 has joined #commonlisp
tyson2 has quit [Read error: Connection reset by peer]
waleee has quit [Ping timeout: 250 seconds]
yauhsien has quit [Ping timeout: 256 seconds]
igemnace has quit [Remote host closed the connection]
saura has joined #commonlisp
saura has quit [Remote host closed the connection]
Mandus_ has quit [Ping timeout: 248 seconds]
Mandus_ has joined #commonlisp
zacts has joined #commonlisp
s-liao has quit [Quit: Client closed]
Mandus_ has quit [Ping timeout: 240 seconds]
Mandus_ has joined #commonlisp
hashfunc1c8d has quit [Remote host closed the connection]
<zacts>
hello commonlisp
<beach>
Hello zacts.
zacts has quit [Quit: Client closed]
poselyqualityles has quit [Ping timeout: 248 seconds]
hashfunc1d0a has joined #commonlisp
aartaka has joined #commonlisp
jmdaemon has joined #commonlisp
zeroc00l0 has quit [Ping timeout: 250 seconds]
Guest74 has joined #commonlisp
zeroc00l0 has joined #commonlisp
triffid has quit [Ping timeout: 240 seconds]
triffid has joined #commonlisp
masinter has quit [Ping timeout: 248 seconds]
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
zeroc00l0 has quit [Ping timeout: 250 seconds]
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
rotateq has joined #commonlisp
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
<jmdaemon>
does the key in gethash always have to be quoted?
rotateq has quit [Remote host closed the connection]
<|3b|>
things that need quoted need quoted, pretty much independent of context
<beach>
jmdaemon: No, it is evaluated normally.
<|3b|>
gethash is a normal function, so key is evaluated, so if you don't want that you need to quote
<beach>
jmdaemon: Are you new here? I don't recognize your nick.
<jmdaemon>
yes am new here beach
<beach>
Great! Welcome!
<jmdaemon>
oh thank you!
<pjb>
jmdaemon: you need to quote only literal values! Variables or expressions are not quoted!
<beach>
jmdaemon: For basic questions about the language, there is also #clschool. Newbie questions are not the main purpose of #commonlisp, but they are tolerated to a certain degree.
<pjb>
jmdaemon: and then, even for literal values, they're self-evaluating, so quoting is only required for lists or symbols:
<pjb>
jmdaemon: (gethash 42 table)
<pjb>
jmdaemon: (gethash 'name table)
<jmdaemon>
okay I will go ask my next questions in clschool then
Guest52 has quit [Quit: Client closed]
zeroc00l0 has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
zacque has quit [Quit: Goodbye :D]
treflip has joined #commonlisp
hashfunc1d0a has quit [Remote host closed the connection]
rotateq has joined #commonlisp
jmdaemon has quit [Ping timeout: 248 seconds]
MajorBiscuit has joined #commonlisp
semz_ is now known as semz
random-nick has joined #commonlisp
shka has joined #commonlisp
semz has quit [Quit: Leaving]
<rotateq>
What do you use to serialize lisp objects to disk so other programs might read it too? I played a bit with the SQLite3 database yesterday and was curious.
random-nick has quit [Ping timeout: 256 seconds]
<rotateq>
And what I didn't achieve yet, to define (deftype varchar (limit) ...) and first a (eval-when (:compile-toplevel :load-toplevel :execute) (defun varcharp (string limit) ...)) that I can use in DEFTYPE with a SATISFIES. I don't know how to connect that in this case.
<Nilby>
rotateq: It totally depends on the data and what you're using it for, but cl:print and (defmethod print-object ..) can work fine, the problems come in using cl:read to read it back.
<rotateq>
Nilby: Ah okay. :) Would be a byte-stream in the end I think to write to or read from.
<Nilby>
lisp print can print nearly anything to any stream, especially with gray streams, since you define what you want to happen. But there are a number of generic data serialization libraries.
<rotateq>
I know there's CLSQL and happy I can use it when we have this long SQL module and am very motivated to deeply learn SQL with some maths for it too, but would be nice to write something myself as a toy thing. So that I can create a table, push objects to an adjustable vector, then "freezing" it in the end to a #2A with the right additional metainformation and store it on disk for later use.
<rotateq>
Oh right gray streams, don't know yet how to use those or where the differences/benefits are.
<Nilby>
i like clsql and used in production, but remember if you're saving to so sqlite3 then you're really writing out strings
<rotateq>
Yes you instantly have much more power. Oh.
<rotateq>
And the CL Cookbook has a long chapter how to use mito, but talking to a created database didn't work out yet, but I'll stay stubborn. :)
<Nilby>
the sbcl manual has a good reference for gray stream methods
<rotateq>
Nice, thank you.
<Nilby>
but for many basic things I just use print
<rotateq>
Yes okay.
<Nilby>
unfortunately for reading i want a patched cl:read
<rotateq>
Nilby: And I remember you as being very competent with FORMAT too. ^^
<rotateq>
So one could use eclector or store the patched reader in another readtable via named-readtables.
<Nilby>
no, i just like more horribly bad format strings than some
<Nilby>
frequently i get by with just writing a magic number, version, then lisp expr
<rotateq>
I had to look up (again) in the spec how to print integers in e.g. binary as "1010 1100" or so.
zeroc00l0 has quit [Ping timeout: 250 seconds]
<rotateq>
Some day I can remember the order of mincol, padchar, commachar, comma-interval.
<Nilby>
but i'm so annoyed with format that there's ~5| but ~5c doesn't work
<Nilby>
like it's just needlessly verbose to print out n variable characters
<rotateq>
Oh right thought some time ago let's try exactly that.
MajorBiscuit has quit [Ping timeout: 250 seconds]
<rotateq>
And yesterday while having a walk I got the thought FORMAT is a function and no macro, so that it evaluates its arguments first before calling FORMATTER. (may sound trivial now)
aartaka has joined #commonlisp
<Nilby>
we
<rotateq>
Just for me, that it makes sense.
<Nilby>
well, many compilers do some tricks to make it faster for constants
<rotateq>
Heh, compiler macros can be powerful. :)
<Nilby>
but of course you can pass it an unevaled list, and have it work on that
<rotateq>
Or producing a control-string with format to give to a next format call.
<Nilby>
e.g (format nil "~{~s~}~%" '(format my (car)))
<rotateq>
For what's again the directive ~| ?
<rotateq>
okay I see
<Nilby>
very uselessly printinga a Control-L (ascii 12)
s-liao has joined #commonlisp
<rotateq>
Yes I tried. (both)
<Nilby>
unless your using a tek4014, which then it clears the screen and saves your phosphors from burning out
<rotateq>
sounds funny
<Nilby>
or a decwriter then it spits your paper to the perforation so you can tear it
<rotateq>
Nilby: So you have good experiences using CLSQL in production? Would be interesting for later too as databases are an important thing.
<Nilby>
yes. it works great. especially at a the lisp repl you can do things that can make enterprise dba's heads spin
<Nilby>
i've used it with sqlite,oracle,mysql,sqlserver via odbc,postgresql, etc
zeroc00l0 has joined #commonlisp
yauhsien has joined #commonlisp
<Nilby>
reddit 1.0 was just on hunchentoot and clsql-postgresql
yauhsien has quit [Ping timeout: 256 seconds]
igemnace has joined #commonlisp
<rotateq>
yeah way more flexible or quickly build new safe abstractions
<rotateq>
and then they shipped to python. but what shall be great is this pgloader
<Nilby>
switching to python shows that programmers are the scarcer resource than cpu
s-liao has quit [Ping timeout: 250 seconds]
<rotateq>
Ah okay if you mean real programmers than yes. :) But okay it's just one part of software engineering.
livoreno has quit [Remote host closed the connection]
livoreno has joined #commonlisp
orestarod has joined #commonlisp
<lonjil>
yes, they switched because Reddit got merged with another YC-funded startup with a similar idea, and the team at that company only had Python experience.
<rotateq>
Ah okay. And I bet good CL programmers are very hard to find, as most of those have already a job.
<Nilby>
or some wouldn't take such a job if you payed them
<lonjil>
IIRC, they were also having trouble with SBCL's threading support on FreeBSD in 2005.
<rotateq>
Nilby: That's the next point, having enough budget to pay.
<rotateq>
Oh.
<rotateq>
Or to not get the illusion that someone who does the same amount of work in 5h is worth the same as one who needs 40h with a different tool.
<rotateq>
Ehm false, "not get the illusion ... can't be ..." of course.
<Nilby>
clsql made it so i could relax while the databases churned
<rotateq>
Nilby: I hope it would be okay if I ask you things at some point.
<Nilby>
sure
<rotateq>
At least it's good SQL has an ANSI standard too.
<zeroc00l0>
What do you think are the best reasons to believe people who are experts in both python and CL are more productive in CL?
<rotateq>
Nilby: Thank you.
<rotateq>
zeroc00l0: That CL doesn't change constantly, so you have a real chance of being an expert after some years for example.
<zeroc00l0>
So you are suggesting there are no expert python programmers?
<rotateq>
No, of course, but it's harder in the long run.
<zeroc00l0>
Okay so, supposing that a person is an expert in both python and CL, why would you believe that they are more productive in CL?
<rotateq>
You aren't trapped in just the thoughts others decided for you.
<rotateq>
Do we have to do such a discussion here? :) Anyone is free using what they want and fits best to their minds.
<zeroc00l0>
Appealing to supposed strengths of CL doesn't seem like a very strong argument to me, as I would expect someone in #python to just appeal to the supposed strengths of python and I don't have a good way to determine which strengths translate into better productivity.
<zeroc00l0>
I was just curious because it sounded like you had an opinion on the issue and I wanted to see if there was some good reason that I was missing out on.
zacts has joined #commonlisp
<rotateq>
zeroc00l0: No I just meant productivity is most often used in a "the longer the better" metric.
<rotateq>
So rethinking the value of work on those not directly seeable things.
<zacts>
is lisp a good "thinking" language?
<Nilby>
i think it's easier to be more productive for easy things in python, because there's already a high quality library for easy stuff, but CL is more prodcutive, or even possible at all, for actually hard things
<zacts>
meaning, it's a good language to brainstorm ideas in
<zeroc00l0>
rotateq: How do you know that many people have this metric for productivity?
<rotateq>
Yes, and big systems.
<rotateq>
zeroc00l0: Oh they don't? well
<zeroc00l0>
rotateq: I don't know if they do or don't.
<rotateq>
Okay.
<zeroc00l0>
zacts: Some people will probably say ruby is a good language to brainstorm in, and the same for perl, f#, whatever.
<zeroc00l0>
Or maybe they wouldn't, I really don't know.
<zacts>
hm..
<rotateq>
After all it's about the person what to pull out of a tool and using it cleverly.
<zacts>
that's a good point
MajorBiscuit has joined #commonlisp
zacts has quit [Quit: Client closed]
igemnace has quit [Remote host closed the connection]
Brucio-61 has quit [Remote host closed the connection]
<beach>
zeroc00l0: There is absolutely no point in trying to compare the productivity of different languages in such a general case. For starters, we have no way of measuring productivity of programmers.
Dynom has joined #commonlisp
<zeroc00l0>
beach: Well, my point might be that I want to pick the tools that will allow me to build my application the fastest or the cheapest. And you might be right that there is currently no data available on programmer productivity. But it doesn't currently seem to me a priori impossible to collect data about programmer productivity.
<beach>
You are right. It is not impossibly, just very expensive.
<beach>
You would have to set up several teams creating "the same" very large product over a long period of time. Nobody has done this for obvious reasons.
<beach>
But there is some work that suggests that productivity depends a lot on the programming language, depending on the type of product being written. See the works by Hudak and Jones. That's the only such work I know of, because the situation seems very unique.
<zeroc00l0>
"Nobody has done this for obvious reasons."
<zeroc00l0>
What is the obvious reason? Given the enormous amount of resources directed to software engineering projects I naively expect there would be tremendous demand for such data.
<beach>
zeroc00l0: The obvious reason is that no organization has any interest in conducting the experiment. It would have to be some independent (and rich) organization doing it. For example, a government deciding what languages to impose in teaching. But I know of no politicians interested in such a subject.
<beach>
zeroc00l0: There is widespread belief in industry that the language being used has almost no influence on productivity. If they didn't believe that, they would not make decisions the way they do now, i.e., "all our programmers know C++, so let's do the job in C++".
tyson2 has joined #commonlisp
<zeroc00l0>
Given that example it sounds like the decision maker has decided the benefit of some other language is outweighed by the cost of training all their developers to that language.
<beach>
zeroc00l0: Yes, but they make such decisions based on incompetence rather than on facts.
<beach>
zeroc00l0: If you believe that the software industry is making good rational decisions, think again!
<Nilby>
the place that i've been told employs the most lisp programmers, also has been interested in measuring programmer productivity for many years, and such businesses are probably reluctant to share such results
<beach>
zeroc00l0: On the average, you can view the software industry as consisting of totally incompetent decisions makers, making decisions for totally incompetent developers.
<beach>
<beach>
Nilby: Good point.
euandreh has joined #commonlisp
<zeroc00l0>
But even if someone were going to try hard to talk sense about programmer productivity, it sounds like there isn't very much they could say right now, given the lack of studies.
<zeroc00l0>
If everyone in the industry is behaving incompetently, don't you expect a bunch of competent people to move in and take over given the well publicized financial rewards for doing well in the space?
<beach>
Exactly. In teaching I use the paper by Hudak and Jones, but there is no solid evidence.
euandreh_ has quit [Ping timeout: 250 seconds]
<beach>
zeroc00l0: However, and this is the main problem in the software industry, the job description of a decision maker is not to behave like a spreadsheet program. If it were the case, they should be replaced by one. The job description is that they should have intuition about these things. But in fact, they have no clue.
euandreh has quit [Ping timeout: 248 seconds]
<zeroc00l0>
It's not clear to me what the word 'intuition' means here. (and how it contrasts with a spreadsheet program)
<beach>
Oh dear!
<beach>
Let's see...
Brucio-61 has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 248 seconds]
<beach>
If all a decision maker does is compare numbers and pick the highest one, then their annual salary is way too high. A secretary can do that.
<beach>
The decision maker should have sufficient experience to choose between solutions when there is NO hard data available. But very few can. So they either behave like spreadsheet programs, or they make decisions based on intuition that is orders of magnitude wrong.
<rotateq>
Or they think just you can't program Java/C# or friends you can't do anything else seriously. Or never touched a computer cause you don't have written "MS Word" in the skill section of your application. Things like that.
Inline__ is now known as Inline
<zeroc00l0>
beach: What type of experience can inform someone about programmer tools and productivity? And if there are such experiences, can't we just poll everyone who has had them to aggregate data about programmer tools and productivity?
<pjb>
rotateq: the problem is that satisfies only takes a predicate, not a function with several arguments.
<pjb>
rotateq: therefore you would have to generate one function for each length limit.
<rotateq>
pjb: Oh right, my initial question.
<rotateq>
So ... let the limit be 80 and do the macro do the rest for the predicate DEFUNs. ^^
<pjb>
rotateq: and the problem with that, is that deftype must expand to a type specifier, so while you can have compilation-time side effects from the deftype body, you cannot bring them to run-time!
<beach>
zeroc00l0: Decisions makers should have first-hand experience with lots of languages and other tools. Currently, it is good if they have programmed at all in the past few decades. And how do you decide who has had enough experience to participate in the poll? We currently crank out huge numbers of badly trained developers who then work using the same language for most of their careers.
<rotateq>
pjb: Hmm okay.
prokhor_ has joined #commonlisp
<pjb>
rotateq: so the only solution is to define a wrapper define-type that expands to a `(progn (eval-when … (defun ,generated-name …)) (deftype … (satifies ,generated-name)))
<beach>
zeroc00l0: As Robert C Martin "Uncle Bob" points out, since the number of programmers currently doubles in 5 years, half the programmers have less than 5 years experience.
<pjb>
rotateq: of course, if you have a lot of different lengths, it would generate a lot of very similar functions, which would be a waste.
<rotateq>
pjb: Would be a good thing to store those parametrized types in a slot with `:type` for checks.
<rotateq>
Yes it would.
<phantomics>
zeroc00l0: the business world runs on emotion before logic, primarily driven by fears (of being left behind, of betting on the wrong horse). Read LinkedIn bios and see all the buzzwords; these are not innovative thinkers.
<pjb>
It's possible. But again, the main problem here is to bring compilation-time side effects to run-time.
<pjb>
The solution provided by CL is an eval-when that will run the side effects at both times.
<zeroc00l0>
phantomics: But if the current market participants are making bad decisions, why don't better decision makers push them off and reap the rewards?
<zeroc00l0>
s/off/out
<phantomics>
Investment money follows trends and a lot of the big publicized successes in software are benefiting from network effects facilitated by big investors. It's also considered a status symbol to have many developers; managers would rather lead 100 Java devs than 10 CL devs
<zeroc00l0>
beach: Certainly I prefer to have a boss who can/does program than the alternative. I don't know if such a figure makes better decisions, but I at least get the sense that he understands more of what I am trying to say.
<rotateq>
That's exactly the point of it.
<beach>
zeroc00l0: Because software development is not like other domains. In most domains, the vast majority of the cost of a product is material and manufacturing. In software, the cost is development divided by number of units sold. So the company with the largest number of units sold wins, no matter how inefficient they are.
<phantomics>
zeroc00l0: the thing about bad software development practice is that the downsides often don't become apparent until after the customers have bought into the product
<beach>
zeroc00l0: Certainly, without such experience, the decision maker is going to make approximations, and one such approximation that is commonly used is to assume that all programming languages are roughly the same.
<phantomics>
With mainstream technologies you can stand up something that will work well at first glance, do the basic things it promises. It starts to fall apart when the system needs to evolve and respond to ongoing demands on it
<zeroc00l0>
beach: " So the company with the largest number of units sold wins, no matter how inefficient they are." So then aren't companies acting rationally by prioritizing the thing that most increases their chance of making profit (rather than something obscure like programmer productivity)?
<beach>
phantomics: Good point. I was describing only the situation of the producer of software to be sold in several units.
<phantomics>
But at this point the company has customers who have been trained by decades of Microsoft quality that buggy unreliable systems are "just the way computers are"
<beach>
zeroc00l0: They still want to maximize profit, and the profit would be even greater with higher productivity. The two are not mutually exclusive.
<beach>
zeroc00l0: And my description does not apply to the situation phantomics mentioned, i.e., custom-written software.
X-Scale has joined #commonlisp
<beach>
Nilby: Might be relevant.
<phantomics>
beach: It's not just about custom-written software but anything that users will adopt before getting an idea of all the problems involved. Take MongoDB, worth billions and an unreliable piece of junk. They had some nice docs and a JSON insterface that got them some developer mindshare and they grew from there.
<MichaelRaskin>
Higher productivity at making working software and at making imitations that are plausible enough to be sold are different things
igemnace has joined #commonlisp
<phantomics>
Mainstream technologies get you something working fast: you can hire developers easily and put together an MVP to show to investors. They're all looking for the unicorn moonshot, they don't care if it will become untenable to develop in 10 years
<beach>
Nilby: Google is certainly big enough that they could get away with something like that for internal purposes.
<beach>
phantomics: Good point.
<Nilby>
they have a whole dept of phds who do that
<Nilby>
not that it really works
<phantomics>
A problem with big companies is that they form a kind of "gravity well" inside which perceptions of the outside world are heavily distorted
<phantomics>
Consider how the US big three automakers were so badly stung by the Japanese, they had every advantage but they still couldn't see why no rational person would pick a car that rusted on the lot and went to the shop every week over a Toyota
<tyson2>
cognitive dissonance
<Nilby>
phantomics: yes indeed, the industry seems full of such gravity wells
MajorBiscuit has joined #commonlisp
<phantomics>
I perceive that right now we're reaching the limits of what can be done in traditional programming paradigms and this will create an opportunity for better approaches to programming. And I'll admit that CL has yet to be used in a tool so obviously superior to alternatives that it becomes a new unquestioned standard. But I can see possibilities on the horizon for that
<zeroc00l0>
phantomics: You believe that mainstream technologies are causing the long term quality of the projects to suffer? So if these same teams had chosen CL or Smalltalk or Factor, ceteris paribus the long term quality of the project would improve?
<rotateq>
zeroc00l0: Or APL. ;)
Inline has quit [Quit: Leaving]
<beach>
zeroc00l0: I for one certainly believe that.
<phantomics>
zeroc00l0: Yes. I started out as a Wordpress developer and there are many WP products that have been built at a staggering cost in time and money that could have been done with a few lines in cl-who.
yauhsien has joined #commonlisp
<phantomics>
Another example: the React Javascript framework. React uses a system of inline HTML in Javascript that depends on a library called Babel. Babel contains 100MB -of code-.
<rotateq>
Oh.
<phantomics>
There is a library called panic that extends parenscript to add primitives for generating react components in a friendly HTMLesque way. Length: a bit over 100 lines. This does the same thing that Babel does.
<zeroc00l0>
beach: So do you find yourself being considerably more productive in CL than whatever mainstream language you know well?
<beach>
zeroc00l0: Yes. That's why I have been using Common Lisp exclusively for the past decades.
<beach>
zeroc00l0: What is your current situation? Do you work in the software industry?
<zeroc00l0>
Okay, fair enough.
<phantomics>
Also, using macros to generate React components can obviate entire frameworks dedicated to maintaining state in a React app. You can specify your shared state using compiler extensions instead of bulky, complicated runtime systems
<Nilby>
download the compiler into your browser before you can view our page, mmky thx
<zeroc00l0>
Currently unemployed, but I have worked in the industry for the last 10 years.
<rotateq>
phantomics: I hope I can do similar when we have to do a project with this Angular JS.
<beach>
zeroc00l0: I see.
<beach>
zeroc00l0: Then you should know that, from my work in industry, it is virtually impossible to try to convince anyone to change for the better by using just arguments. I did it by showing that I was very productive, and only then did people become interested in what I was doing better.
yauhsien has quit [Ping timeout: 246 seconds]
<zeroc00l0>
Do you have a specific example?
<beach>
It would be a bit long to describe. Let me see if I have an example written down somewhere...
<phantomics>
zeroc00l0: here are some anecdotal productivity metrics. I wrote a compiler for the APL language in about two years' total working time. It has equivalent features to Dyalog APL, the leading commercial APL interpreter, which has been worked on for almost 40 years now. My compiler is ~12KLoC, Dyalog's core is >100KLoC (the applicatiion in total is over half a million lines)
<rotateq>
phantomics: And very much potential to improve further. :) Without minor overoptimizations.
<zeroc00l0>
phantomics: And presumably you and Dyalog used different implementation stacks?
<phantomics>
I am not yet as fast as Dyalog but am currently working on features that their C++ architecture makes prohibitive for them to even attempt. Sources close to the devs say that the code base is so huge and unwieldy it's an ordeal to make even minor changes
<beach>
zeroc00l0: I don't seem to have it written down. Sorry.
<zeroc00l0>
beach: No problem, thanks for looking.
<phantomics>
zeroc00l0: my compiler has zero code in common with Dyalog, it's CL from the ground up. The best-known FOSS APL implementation, GNU APL, is also 100KLoC of C++ with many fewer features than April (my compiler). I've been able to make significant changes to the model and add new features in less than a day. Replacing the entire core compiler took me 1.5 weeks. That's at least a productivity anecdote
MajorBiscuit has quit [Ping timeout: 246 seconds]
<Nilby>
phantomics: awesome, that's kind of multiple exponent productivity we need
<Nilby>
a guy from franz told me 1 guy wrote their CL from scratch in 1 year, also there's Roger Corman who did nearly the same, and froggy who did a whole CL + OS
<phantomics>
Now Lisps are a big project, much respect to the people who write them. I like array languages since it's easy to specify the language's behavior in a spec. Because they're so terse I can easily write many unit tests and put them directly into the spec as well
<Nilby>
phantomics: i'm most impressed that you can think in both languages at the same time, with such a different surface
<rotateq>
phantomics: I still have to think hard how a good way would be putting property tests into April, so let those tests being generated themselves. And of course what we talked about, the possible branch for a CLOS APL. :)
<phantomics>
rotateq: On that note... stay tuned.
<rotateq>
Just please don't expect too much from me either.
<phantomics>
There are surprising commonalities between the languages beneath the surface, there's always been some cross-pollination between then, Steele's CLtL has several references to APL. The CL array model was definitely influenced by APL, with row-major ordering and zero-rank arrays
<rotateq>
Yes, pfd pointed me to those yesterday.
<rotateq>
Or we could explore how to bring in more the power of the condition system. When doing something wrong on tryapl.org then it just says things like "Length error". Okay, but where and how to recover?
<phantomics>
rotateq: There's a lot of room for growth there. I have some verbose error messages but some other errors will manifest in the underlying CL and give stack traces that won't make sense to an APL dev
<rotateq>
Or as I asked some time, bringing in compiler macros too.
<phantomics>
Vector language macros are an interesting topic, they have been implemented in some languages, including k I think
dec0d3r has joined #commonlisp
yauhsien has joined #commonlisp
razetime has joined #commonlisp
aartaka has quit [Ping timeout: 250 seconds]
aartaka has joined #commonlisp
Inline has joined #commonlisp
Bike has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
razetime has quit [Remote host closed the connection]
triffid has quit [Ping timeout: 240 seconds]
triffid has joined #commonlisp
jsatk__ has quit [Ping timeout: 248 seconds]
conjunctive has quit [Ping timeout: 245 seconds]
random-nick has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
zacts has joined #commonlisp
jsatk__ has joined #commonlisp
azimut has quit [Remote host closed the connection]
conjunctive has joined #commonlisp
azimut has joined #commonlisp
treflip has quit [Remote host closed the connection]
treflip has joined #commonlisp
zacts has quit [Quit: Client closed]
Madsy has quit [Ping timeout: 272 seconds]
tyson2 has joined #commonlisp
igemnace has quit [Remote host closed the connection]
zeroc00l0 has quit [Quit: Client closed]
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 248 seconds]
X-Scale` is now known as X-Scale
zacts has joined #commonlisp
waleee has joined #commonlisp
masinter has joined #commonlisp
zacts has quit [Ping timeout: 250 seconds]
occ has quit [Ping timeout: 240 seconds]
yauhsien has quit [Remote host closed the connection]
[deleted] has joined #commonlisp
livoreno has quit [Ping timeout: 250 seconds]
notzmv has quit [Ping timeout: 250 seconds]
yauhsien has joined #commonlisp
zmv has joined #commonlisp
zmv is now known as notzmv
notzmv has quit [Changing host]
notzmv has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
MajorBiscuit has joined #commonlisp
jmdaemon has joined #commonlisp
Madsy has joined #commonlisp
igemnace has joined #commonlisp
Inline has quit [Remote host closed the connection]
MajorBiscuit has quit [Ping timeout: 248 seconds]
Bike has quit [Quit: Connection closed]
karlosz has joined #commonlisp
karlosz_ has joined #commonlisp
karlosz has quit [Ping timeout: 248 seconds]
karlosz_ is now known as karlosz
karlosz has quit [Ping timeout: 240 seconds]
MajorBiscuit has joined #commonlisp
Bike has joined #commonlisp
tane has joined #commonlisp
tane has quit [Changing host]
tane has joined #commonlisp
treflip has quit [Quit: good night!]
karlosz has joined #commonlisp
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
poselyqualityles has joined #commonlisp
[deleted] has quit [Ping timeout: 240 seconds]
cage has quit [Remote host closed the connection]
MajorBiscuit has quit [Ping timeout: 250 seconds]
Inline has joined #commonlisp
morganw has joined #commonlisp
Guest74 has quit [Quit: Connection closed]
oselyqualitylesp has joined #commonlisp
karlosz has quit [Quit: karlosz]
Oladon has joined #commonlisp
attila_lendvai has joined #commonlisp
poselyqualityles has quit [Quit: Using Circe, the loveliest of all IRC clients]
oselyqualitylesp has quit [Read error: Connection reset by peer]
poselyqualityles has joined #commonlisp
wmblathers has quit [Quit: Leaving...]
masinter has quit [Ping timeout: 250 seconds]
siganon has joined #commonlisp
siganon has quit [Changing host]
siganon has joined #commonlisp
sndr is now known as sander
wmblathers has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
wglb has joined #commonlisp
tyson2 has joined #commonlisp
yauhsien has quit [Ping timeout: 250 seconds]
livoreno has joined #commonlisp
<siganon>
so I was looking at the project emotiq because it came up in a search for a common lisp blockchain, but read that it had be rewritten in Rust. I only found an ambiguous comment about how they thought lisp would be a good idea but that it didn't work for what they were trying to do. anyone familiar with this project, now called stegos, and why Rust would be better for this type of project?
masinter has joined #commonlisp
citizenandrew has joined #commonlisp
yauhsien has joined #commonlisp
citizenandrew has quit [Quit: Client closed]
Lord_of_Life_ has joined #commonlisp
yauhsien has quit [Ping timeout: 248 seconds]
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
Dynom has quit [Quit: WeeChat 3.5]
Inline has quit [Quit: Leaving]
<lagash>
memory safety! /s
<edgar-rft>
my memories are getiing more an more unsafe
siganon has quit [Remote host closed the connection]
Inline has joined #commonlisp
attila_lendvai has quit [Ping timeout: 250 seconds]
aartaka has quit [Ping timeout: 240 seconds]
MajorBiscuit has joined #commonlisp
aartaka has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
prokhor__ has joined #commonlisp
poselyqualityles has quit [Ping timeout: 250 seconds]
prokhor_ has quit [Ping timeout: 248 seconds]
poselyqualityles has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 3.4]
jmdaemon has quit [Ping timeout: 250 seconds]
orestarod has quit [Ping timeout: 240 seconds]
jmdaemon has joined #commonlisp
triffid has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 240 seconds]
occ has joined #commonlisp
random-nick has quit [Ping timeout: 256 seconds]
m5zs7k has quit [Quit: m5zs7k]
cosimone` has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
occ has quit [Ping timeout: 240 seconds]
tane has quit [Quit: Leaving]
livoreno has quit [Read error: Connection reset by peer]
morganw has quit [Remote host closed the connection]
igemnace has quit [Remote host closed the connection]
poselyqualityles has quit [Ping timeout: 248 seconds]