<clacke[m]>
beneroth: > later learned picolisp as my first lisp language.
<clacke[m]>
Perhaps the only person in human history :-D
<clacke[m]>
C is an important language to learn at some point. Probably not as an introduction to programming, but as the second or third language, once you have grasped the fundamentals of programming and need to learn about computers.
<clacke[m]>
C++ isn't an important language for any other reason than lots of legacy code using it. Which might be a good enough reason to learn it, but I'd learn it on the job.
<clacke[m]>
I think the languages clearly wanting to replace C++ are Java, C# and D. Rust obviously is a C++ replacement in the sense that it came from Mozilla wanting to get away from C++. But I see Rust more as something other than "C++, but good", which is quite the focus of the mentioned three, even though they each also have their own directions that are separate from just being a better C++.
<clacke[m]>
> C/C++ programs (or even just parts of it) can easily be used with picolisp. how is this with scheme?
<clacke[m]>
Can't do it in standardized Scheme, but all of Racket, Guile, Chicken, Chibi, Scheme48, Gambit, Chez can do it by calling C over an FFI and/or being embedded in a C program.
orivej has quit [Ping timeout: 260 seconds]
orivej has joined #picolisp
<beneroth>
interesting, thanks clacke[m] :D
<beneroth>
when I wanted to learn lisp, I looked at CL: compiler-dependencies, lib dependencies - I didn't want that, this was one of the main reasons (beside increasing developer speed) I wanted to get away from C++. so I looked for other lisps and landed here. Didn't know about scheme then.
f8l has quit [Ping timeout: 246 seconds]
<cess11_>
Good morning.
<Regenaxer>
Hi beneroth, cess11_
<beneroth>
Good morning cess11_, Regenaxer :)
Regenaxer has quit [*.net *.split]
Regenaxer has joined #picolisp
rob_w has joined #picolisp
<clacke[m]>
scheme and CL are pretty similar in how you use them. The main differences are how you spell things, how big the standard library is and of course whether functions and variables occupy the same slot in the symbols or not.
<clacke[m]>
There are compilers, possibly linkers, so there are macros and compile-time and run-time. picolisp just doing interpretation and fexprs are conceptually simpler for sure.
<clacke[m]>
is*
<Regenaxer>
Right. The similar "feel" results from being compiler-oriented, static, (Scheme more than CL) I think
<beneroth>
picolisps architecture is extreme, no doubt about it. the point is that it is practical without all the (bloat-causing) usual compromises
<beneroth>
people were/are told that doesn't work that they can't believe it and have a hard time even thinking about it :)
<beneroth>
bbl
<clacke[m]>
the trick is that most code isn't tight, number-crunching loops, and most people can't accept that because that kind of performance is the holy grail
<beneroth>
T
<Regenaxer>
cu beneroth
<clacke[m]>
and the second trick is of course then when you're indeed in that kind of loop, you can just farm that out to a language that does that
<beneroth>
it reduces their self-image becoming aware that most things they do is bad code glueing ;)
<clacke[m]>
when it comes to static typing, racket is an interesting beast
<clacke[m]>
there is typed-racket
<clacke[m]>
yeah, that's low-status work
<clacke[m]>
our product is awesome so it needs to idle really fast
<Regenaxer>
:)
alexshendi has quit [Ping timeout: 264 seconds]
<clacke[m]>
so typed-racket, if you write everything in typed-racket, is faster than plain racket. but if you mix your rackets, each transition is costly. basically each call from dynamic to static needs runtime type checking
mtsd has joined #picolisp
<clacke[m]>
and even some of the core for typed-racket is dynamic
<clacke[m]>
so it really really depends
<clacke[m]>
you can't even be sure that perf monotonically increases as you convert module by module. covert the wrong module first, and that may introduce lots of transitions.
<cess11_>
Sounds tricky.
<cess11_>
As for D and Rust I think the former seems more like an attempt to recreate C++ but with elegance, with Rust going more for 'who cares, let's just add the things that would make it easier to use'.
<clacke[m]>
yes, D is about making things possible and compiling fast, and Rust is about zero-cost (at runtime) abstractions and memory management without gc
<clacke[m]>
the framework we are developing has racket and typed-racket at the top, with the ability to go into Rust when required
<clacke[m]>
the Rust parts are pre-existing, we are doing Racket integration and IDE work now (in Racket)
orivej has quit [Ping timeout: 246 seconds]
alexshendi has joined #picolisp
alexshendi has quit [Ping timeout: 276 seconds]
<beneroth>
re
<beneroth>
interesting :)
<cess11_>
'+Link can point to any object, no? So a '(+List +Link) could be used for ad hoc collections of static data for viewing in a GUI?
<cess11_>
As in manually set up but browseable as a web GUI page that just iterates over the objects in that field and assuming a field exists in those objects renders that data and some button for following its links.
<Regenaxer>
yes, so perhaps (+List +Link) to (+Any)
alexshendi has joined #picolisp
<cess11_>
Great, thanks.
<cess11_>
If I get it right I hope to do a write-up tomorrow sometime.
<Regenaxer>
Good
shpx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<clacke[m]>
> JavaScript 4K demo competition! Build an amazing app with fewer than 4096 dependencies
<beneroth>
4k limit used to mean something different in demoscene, haha
trui has joined #picolisp
<trui>
hellos
<Regenaxer>
Hi trui
freeemint has joined #picolisp
<freeemint>
I played a little with pilog and the db ...
<freeemint>
i did like it
<Regenaxer>
Good to hear :)
<freeemint>
However i was kinda annoyed by the verbosity caused.by two different name spaces
<freeemint>
for what reason did you choose to seperate them?
<Regenaxer>
There is no different namespace (?)
orivej has joined #picolisp
<beneroth>
hi freeemint :) what are you talking about. do you have an example?
<clacke[m]>
beneroth: in case you didn't catch it, that was the joke :-)
<clacke[m]>
(the 4k limit)
<clacke[m]>
but some serious commentary later in the discussion.
<freeemint>
(^ @ (<> (-> @P) (-> @C))) should be (<> @P @C)
<freeemint>
but it is not
<Regenaxer>
no
<Regenaxer>
these are not namespaces
<freeemint>
so there got to be a reason to.choose verbosity
<Regenaxer>
The symbols are all the same
<beneroth>
clacke[m], I catched that, was obvious. I didn't check out the discussion yet tbh xD
<Regenaxer>
freeemint, you confuse value binding with namespaces
<Regenaxer>
And Prolog has a different system
<Regenaxer>
It is called "unification"
<clacke[m]>
I'm using node2nix for some things I want to use (secure-scuttlebutt), and when you generate the nix from the package.json it needs to go out and index all the transitive dependencies. and that's literally hundreds.
<beneroth>
freeemint, this are two different languages. Pilog is a DSL implemented in PicoLisp, kinda.
<Regenaxer>
There are no value bindings involved
<freeemint>
ok ...
<freeemint>
why did you decide to make pilog so verbous ...
<Regenaxer>
For example?
<freeemint>
see above
<Regenaxer>
(^ @ (<> (-> @P) (-> @C))) is a Lisp expression
<freeemint>
why ^ and -> to work with lisp
<Regenaxer>
It needs to retrieve the current values in the Pilog bindings
<beneroth>
because within pilog you normally have only access to pilog bindings. only when there is no pilog way you should retrieve picolisp values
<Regenaxer>
(<> @P @C) would match a Pilog predicate '<>'
<Regenaxer>
(be <> (@X ...
<Regenaxer>
which does not exist, so we fall back into Lisp
<beneroth>
or (not (same)) :)
<freeemint>
and why not put the pilog predicates in.the function name dpace while.you are in ?
<Regenaxer>
'same' is more, here 'equal' is enough
<Regenaxer>
(be <> (@X @Y) (not (equal @X @Y)))
<Regenaxer>
then you can call (<> @P @C) in Pilog :)
<beneroth>
pilog is another language, it's VM is implemented within picolisp and as FFI interface to picolisp.
<beneroth>
maybe see it this way.
<Regenaxer>
correct
<beneroth>
its not a different "namespace" as "namespace" is a well-defined term meaning modularization within the same language.
<Regenaxer>
yep
<Regenaxer>
namespaces are about finding symbols in the reader
<Regenaxer>
that's all
<Regenaxer>
only the reader and printer
<beneroth>
and the pilog language looks different than picolisp because its basically Prolog with picolisp-like syntax
<freeemint>
function ne space is the normal binding
<freeemint>
(i mean the normal.binding)
<freeemint>
better term?
<freeemint>
ok
<freeemint>
and why do not put @PilogVar in the same binding as normal var?
<Regenaxer>
binding is ok
<Regenaxer>
you can't use the Lisp symbol bindings here
<freeemint>
why?
<Regenaxer>
Pilog does not even look at the values of symbols
<Regenaxer>
As beneroth said, a completely different VM
<Regenaxer>
The current binding of a symbol depends on the backtracking level
<freeemint>
why?
<Regenaxer>
Because Prolog works this way
<freeemint>
yes it does
<beneroth>
compare it to work with a third party program with which you interface via CLI (via 'in 'pipe 'call or so) or (native), then those two programs also (usually) don't share memory, have different variables, different meaning, different ways to work with variables.
<Regenaxer>
not my invention :)
<freeemint>
ok i would have prefered it the semamtics had stayed thr same ... namely minimal
<Regenaxer>
Not possible, believe me
<Regenaxer>
The semamtics are different, that's why we want to use Prolog
<beneroth>
you can explicitly connect/bind variables in picolisp with "bindings"/"values" in pilog (as in the head of the argument list for (goal)), but normally they are completely different things
<freeemint>
because you want to evaluate lisp experssion to buold pilog expressions thaz are evaluated again?
<beneroth>
yes.
<beneroth>
to start with the DB, I would recommend to stay within picolisp for the beginning.
<freeemint>
i see the "macro"s woild grow ugly and you could.not have @ be pattern and pil variable...
<beneroth>
the problem is not the syntax. this was not a syntax design decision. the cause is its two separated interpreters.
<freeemint>
i see
<beneroth>
pilog for the DB becomes interesting when you write big complex queries which are too big/complex to be written into pure picolisp code (with reasonable effort)
<Regenaxer>
freeemint means to bind all variables in the expression in Lisp
<freeemint>
has somebody experience how mamy times pilog is slower than a native prolog?
<Regenaxer>
this would be possible, but too expensive
<Regenaxer>
The whole expression must be analysed first
<Regenaxer>
to find all pattern vars
<Regenaxer>
then look them all up
<Regenaxer>
and bind/unbind them
<Regenaxer>
So (-> ..) only looks up what is needed
<Regenaxer>
Does this explain your question?
<freeemint>
yes
<freeemint>
but not my latest one
<freeemint>
i only need a rough guestimate
<Regenaxer>
Yeah, but I did not try. Never used real Prolog
<beneroth>
I haven't yet met anyone who works with prolog and databaes
<Regenaxer>
only read books
<Regenaxer>
In DB context, I think Pilog is not the bottleneck anyway
<Regenaxer>
For normal Pilog vs. Prolog programs I don't know
<Regenaxer>
Real Prolog will be surely faster
<Regenaxer>
They use lots of native structures and optimizations
<Regenaxer>
Pilog uses a simple linear lookup
<freeemint>
another question if we have a list of 10000 Persons in the DB and we search the first to match several criterions will pilog be have as prolog in these sense that not all 10000 will be expected.
<freeemint>
*processed
<beneroth>
a more relevant comparison would probably be with complex SQL queries. but there are huge differences comparing a SQL DB to pilDB with pilog. pilDB is a graph DB so much faster with JOINS (especially nested JOINS). pilDB runs within pil VM, which is likely slower than a native program, but pil and pilog queries are fully written by the developer/user, while SQL queries are parsed, interpreted, using a complex machinery to attempt approximate optimal db que
<beneroth>
rying.
<freeemint>
and it will stop once it found one.
<Regenaxer>
The GUI search dialogs do that
<Regenaxer>
find only the first 20 or so hits
<Regenaxer>
as big as the +QueryChart is
<freeemint>
ah cool
<Regenaxer>
Then the scroll buttons continue the search
<Regenaxer>
For this Pilog is not absolutely needed, you can do the same with 'init' and 'step'
<Regenaxer>
but much more low-level
<Regenaxer>
and only a single index tree with 'init' / 'step'
<freeemint>
in tje docs it said something along the lone that complex.queries tend to be faster in pilog than in normal lisp
<freeemint>
can you comment
<Regenaxer>
I would not expect so
<freeemint>
ok
<Regenaxer>
But the 'select' predicate does a self-optimizing search
<Regenaxer>
Perhaps this is meant
<freeemint>
explain
<freeemint>
yes it was
<Regenaxer>
But of course the same could be done directly in Lisp
<Regenaxer>
'select' iterates all requested index trees in "parallel"
<freeemint>
ahh
<Regenaxer>
and those with most matches propagate in front
<freeemint>
and the first who finishes is taken?
<Regenaxer>
a simple LRU scheme
<Regenaxer>
right
<Regenaxer>
as soon as one index is done, the whole search terminates
<Regenaxer>
cause it is an AND for all criteria
<freeemint>
how does that "most matches" help with speed?
<Regenaxer>
It does not fetch so many irrelevant objects
<freeemint>
ahh
<freeemint>
but that approach trades troughput for speed doesnt it?
<Regenaxer>
Optimal would be to search the index with the least entries
<freeemint>
yes
<beneroth>
traditional databases often try to figure out the best index for a query, then run through all entries in that one index and do all additional checks later. pilog tries to find the best index on every fetch of a result.
<Regenaxer>
but that is known only after the search is done ;)
<Regenaxer>
T
<Regenaxer>
"trades troughput for speed" I would not say
<Regenaxer>
troughput is speed
<freeemint>
... the one in which the search time + processing time per objekt in the search is the lowest
<Regenaxer>
yes
<beneroth>
so when a database is hit a lot with the exactly same query -> traditional approach might be better (once the system has statistics from the past usage, and uses them clever - its a bit random). when you have lots different queries, the pilog approach tends to be better, could be much better.
<freeemint>
regenaxer trougput != speed
<beneroth>
another factor is that every needlessly checked record is a waste of IO, as those records get loaded from disk into RAM only to find out then that they are the wrong ones.
<beneroth>
throughput is the only speed that matters in practice, no? :)
<beneroth>
other speed measurements are basically about "which system is idling quicker" or is "faster" going through unnecessary loops
<beneroth>
no? :P
<beneroth>
(maybe I overlook something)
mtsd has left #picolisp ["Leaving"]
<Regenaxer>
I would think so too
_whitelogger has joined #picolisp
<freeemint>
cess11_ i hope that at some point you realize that much of my talk is dedicated to idle philosophy
<cess11_>
And in an actual application you'll find that backtracking and fact/rule logic is way nicer than, say, interleaving lazy seq:s or something.
<cess11_>
Sure, I'm just passing on my view and experiences crunching stuff with pil.
rob_w has quit [Quit: Leaving]
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #picolisp
<freeemint>
cess11_ how much data crunching do you get per second
<freeemint>
do you saturate your disk speed or is picolisp the bottleneck
<cess11_>
Usually RAM and CPU are the bottlenecks.
<cess11_>
Or network latency.
<freeemint>
so if you choose another programming language you could process more data?
<cess11_>
Sometimes, but then I'd need to cut down on flexibility and use compilation, which is expensive and tiresome.
<freeemint>
so you trade off dev time with more hardware?
<freeemint>
do you have a guestimate how much more hardware you need to get the same job done?
<cess11_>
At the moment 2 cores, 2 GB RAM, is enough for most of my processing.
<beneroth>
this is not much by current standards afaik
<beneroth>
this is not enough to run a current windows really :D
<beneroth>
freeemint, philosophy is interesting and theorising some is important. but often idle philosophy is just a way to procrastinate, to not do meaningful stuff which actually is less hard than one thinks. just do it.
<beneroth>
so is my experience, at least.
<freeemint>
beneroth T
<beneroth>
really nice analogy with the brick house building. will try to remember it for future use :)
<cess11_>
I have objects representing all swedish "kommuner" and public statistics about them there, mostly election data and key indicators but also a little about kid's health and opinions.
<beneroth>
you're doing a 'cambridge analytics'? (yes new term. though its debatable if they actually did).
<cess11_>
Perhaps, not started profiling real people yet but I probably will, if only to learn and explore.
<freeemint>
cess11_ got some interesting insights about the pirates over there
<beneroth>
the pirate party? yeah?
<beneroth>
do you have a website or so about your findings?
<cess11_>
It is very broken but I'm piecing one together and will share it here eventually.
<cess11_>
Social democrat, but I'm sort of the only one doing stuff like this on the left here.
<beneroth>
interesting. good luck with your endeavours.
<cess11_>
If the Pirate Party wasn't as shallow and dumb as it is around here I might have joined them instead when I got into party politics.
<cess11_>
Last year I had a job where I got to start some of this but they were a little short on cash and didn't see the potential in mining public statistics in the world's leading nation in public statistics.
<beneroth>
dunno how it is Sweden. Pirate Party in DE and CH was mostly a pure joke, they got too many people involved not doing much meaningful.
<cess11_>
Partly because of this I'm now trying some ideas as a business of my own, got the IRS registration just a couple of days ago.
<cess11_>
Yeah, sort of the same here. I'm good friends with some of their more important activists though, as you noticed I have interests they commonly share.
<beneroth>
and I see a general trend that the left either only (well mostly) does symbol politics (nice ideas, but no practical concepts whatsoever), or are busy fighting themselves on how pure they are.
<cess11_>
Many do, yes, and it makes party leaders nervous and short sighted and stupid. I think we'll lose the election due to such leadership.
<beneroth>
yeah, I strongly believe that common ground is the base to build on.
<cess11_>
Local democratic organising and common ground I consider critical for beginning to steer out of the consumist apocalypse we're headed for over the next century or two.
<beneroth>
consumist apocalypse?
<beneroth>
what do you think will happen?
<cess11_>
The petroleum addicted way of producing, packaging and distributing of necessary goods and services will cause our habitat to become quite nasty.
<cess11_>
We need to move to some different model for this quite fast or we'll just boil off in a few hundred years, we won't be able to survive as a species once the atmosphere starts losing oxygen and the food monocultures collapse.
<cess11_>
Part of it is waged labour as the main means for everyday work and survival, but it is the imperative of neverending accumulation of profits and capital that is the really tricky enemy in this. We all think more is better since scarcity was a dominating force in our evolution.
<cess11_>
Not that I think I have the solutions though. I'm just hoping democratisation and critical thinking might be the best available means to change direction as a collective or species.
<beneroth>
I would use different words, but I think we have the same view on this.
<cess11_>
As for the DB projects, my main aim today is fitting together a few data sets that can be interactively explored and compared and use that to sell my services as developer and analyst while explaining how things actually work and why in our economy and public sector. Once that is up to a jog I'll start tinkering with a pil version of 'Google Forms' and send out questionnaires to politicians and public le
<cess11_>
aders for profiling.
<freeemint>
cess11_ what is in your statistical tool.box?
<cess11_>
Basic stuff, simple regression analysis would be the most advanced I've used in pil as of yet, but there'll probably be use for more inspiring stuff further down the line.
<cess11_>
beneroth: Yeah, reductionist and pseudo-organic for the most part, at least big companies.
<freeemint>
simple = linear??
<cess11_>
Yeah, and few variables.
<cess11_>
Plotting a guess from a few data points, that kind of basic and simple.
<freeemint>
how do you plot?
<cess11_>
It takes quite some time to figure out what one wants to measure and compute a trend for and how to keep track of, er, fault margin? Fault? Not sure about the english terms, it's easy to make bad estimations basically.
<freeemint>
and how do you view the plot?
<freeemint>
error
<cess11_>
Numbers in the REPL, the canvas demo and once as a scripted SVG, which I will most likely use more in the future.
<cess11_>
Right.
<freeemint>
you are searching for "error" as in "messuring error"
<freeemint>
meassuring
<freeemint>
cess11_ would you be interested in a jupyter notebook with picolisp instead of python?
<freeemint>
and a gnuplot binding
<freeemint>
??
alexshendi has quit [Quit: Leaving]
<freeemint>
jupyter notebook uses zeromq to talk to "kernels" and we got a zeromq binding
<freeemint>
if somebody wrote a pyplot/gnuplot binding you quivkly would have an "as good as it gets" data exploration environment
<cess11_>
It's something like that I'm building.
<cess11_>
Further down the line I might look into 0MQ, Nanomsg and the others for high performance distributed stuff, but at the moment it's more important to figure out how to model the ontologies involved.
<freeemint>
jupyter notebooks are really nice to work with
<freeemint>
and if you can get the plotting worj it just very much magic
<cess11_>
And the canvas demo is basically a real time plot if used right. Yeah, so I've heard, but python is clunky and a few days later the code is unreadable so I haven't spent much time with those.
<freeemint>
maybe it was not clear you replace python with other languages and inherit all the server stuff from.juypter
<cess11_>
It's also half a disaster that python is two incompatible languages where the old one should have gone away 2015 but is still around and crucial since there are important libraries no one seems to want to port.
<freeemint>
yeah
<cess11_>
Yeah, I just explained why I haven't already put some effort in.
<cess11_>
Or rather just stuck to pil.
<cess11_>
I've tried outsourcing to Postgres and Redis but it's more work and stuff that breaks.
<cess11_>
Plotting is actually the easiest part, in my opinion. Modeling and deciding on what to compute, what to cache and what to load from external sources takes more time and testing.
<freeemint>
i see
<cess11_>
If you looked at the Zappel code you saw a clever way to render a real time plot, and the svg.l can be used for similar purposes. And if that isn't enough later on I'll probably just load a JS lib or hack some up for controlling a SVG-element.
orivej has quit [Ping timeout: 264 seconds]
<freeemint>
cess11_ what do you use real-time plots for atm?
<cess11_>
Nothing but I've done some learning and testing with it.
<freeemint>
i thought so
<cess11_>
Eventually it will be nice to have a real time status box on some landing page, perhaps visualisations of patterns in automatically gathered data, that sort of thing.
<freeemint>
Regenaxer ... gnuplot can take commands in a pipe.
<cess11_>
It's fairly cheap and easy to parse natural language with a text or headless browser as HTTP client and pil for doing the analysis, that kind of work lends itself to real time graphics fairly well.
<Regenaxer>
Yes, I used gnuplot
<freeemint>
Can i open a programm in a pipe
<Regenaxer>
Plotting sensor data
<freeemint>
can i keep a pipe (or a filedescriptor) open in the sense that i can 'in into it then do something else and than later 'in again...
<Regenaxer>
sure
<Regenaxer>
See the Android interface
<Regenaxer>
Or to Java (older version) in @java/lib.l
<freeemint>
Regenaxer. What so solution is preferable?
<Regenaxer>
For what?
<freeemint>
for a gnuPlot library in Picolisp
<Regenaxer>
No idea
<freeemint>
- function that assumes parameter and plots stuff
<Regenaxer>
A lib is not needed
<Regenaxer>
Gnuplot *is* a lib
<Regenaxer>
just call it as in the above example
<freeemint>
- function that takes everything as a parameter (maybe keyword)
<freeemint>
- exposing the complete gnu plot lang in a pilog style?
<freeemint>
- plots as objects with methods which prepare the plot for rendering
<freeemint>
1, 2, 3 oder 4?
<Regenaxer>
No idea
<freeemint>
ok
<freeemint>
all others?
<Regenaxer>
I decide such things as needed. No general rule
<Regenaxer>
Bottom-up usually
Mat4 has quit [Ping timeout: 268 seconds]
<freeemint>
could it be that bottom.up is prefered because a lack of libraries?
<Regenaxer>
I don't think so
<Regenaxer>
I always worked like that, even in childhood with model railroads and rc airplanes
<Regenaxer>
Pil usually needs no lib where other langs do
<cess11_>
It would need testing against probable use cases to determine how you should develop such bindings, GP is very general and flexible.
<cess11_>
It is however easy and fun from the REPL.
<cess11_>
You create a class for logging results and different parameters to the external lib or program and then use 'dm or ad hoc instructions to figure out the details.
<cess11_>
My last Github upload was something like that, a few hacks to automate nmap stuff.
<cess11_>
Like the example above using files is simple to, I've done lots of web scraping by outputting shell scripts and as long as the scripted task takes some time to perform file I/O won't be a problem (it will however be a bottleneck when scanning LAN).
<cess11_>
One of the best things with pil is that powerful code is cheap, it doesn't matter much if you mess up or forgot to write your functions since the time to rewrite them is generally very short.
<cess11_>
Same as the reason why no CL projects ever get finished or even leave alpha, but even quicker development.
<freeemint>
i found another lis.based webserver
<freeemint>
GNU Artanis
<freeemint>
It runs on guile
<cess11_>
There's also CL Woo if you haven't found it. High performance in benchmarks.
<cess11_>
In general only useful when you want to serve millions of concurrent users.
freeemint has quit [Ping timeout: 264 seconds]
trui has quit [Ping timeout: 256 seconds]
alexshendi has joined #picolisp
trui has joined #picolisp
dtornabene has joined #picolisp
orivej has joined #picolisp
shpx has joined #picolisp
dtornabene has quit [Read error: Connection reset by peer]
trui2 has joined #picolisp
trui has quit [Read error: Connection reset by peer]
alexshendi has quit [Read error: Connection reset by peer]
trui2 has quit [Read error: Connection reset by peer]
pcell has joined #picolisp
shpx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
shpx has joined #picolisp
trui2 has joined #picolisp
dtornabene has joined #picolisp
eric has joined #picolisp
eric is now known as Guest492
Guest492 has quit [Client Quit]
cilz has joined #picolisp
cilz has quit [Quit: Using Circe, the loveliest of all IRC clients]