<aeth>
I guess I could just have *cache* be unbound and then do (boundp '*cache*) instead. This might be more useful if you give it a type because instead of DECLAIMing the type (or null foo) you can just declaim the type to be foo and then no user can set it to NIL after it was already initialized once. But in my particular example you probably want to be able to let the user run it all again.
<aeth>
(This is, of course, assuming you are using an implementation that respects type declarations.)
Kaisyu has joined #lisp
X-Scale has joined #lisp
quazimodo has joined #lisp
<aeth>
Oh note that if you're using defvar you probably only want to use it in one location and set it in one location, if you don't want to wind up with unexpected results.
<aeth>
e.g. this is the only place where *cache* should show up (fixed): (if (and *cache* cache-p) *cache* (setf *cache* (really-expensive-computation-that-takes-a-minute)))
<aeth>
It essentially becomes the API function for that variable, which shouldn't be exported in the package.
JetJej has quit [Read error: Connection reset by peer]
Mr-Potter has quit [Quit: Leaving]
dale has joined #lisp
shifty has quit [Ping timeout: 245 seconds]
igemnace has joined #lisp
shifty has joined #lisp
quazimodo has quit [Ping timeout: 245 seconds]
permagreen has quit [Remote host closed the connection]
rritoch has joined #lisp
<rritoch>
Hi, I have questions about packages but I'm not entirely sure how to word them so please be patient with me.
<rritoch>
A package contains variables, macro's and functions, but does it contain anything else?
<aeth>
rritoch: A package is just a namespace for symbols.
<verisimilitude>
A package contains symbols, including whether the symbol was imported from elsewhere, created there, is external, is internal, etc.
<aeth>
rritoch: The full name of the symbol is foobar:foo but if you are inside of the package foobar or use the package foobar or import foo from foobar you can refer to it as foo
<rritoch>
aeth: But doesn't the packages have two namespaces, one for variables, and one for functions & macro's ?
<aeth>
rritoch: There are two kinds of namespaces and they sort of combine.
<verisimilitude>
There are more than that, you could argue.
<aeth>
rritoch: foobar:foo is the symbol foo in the namespace foobar, which could depending on the context it is used in be referring to a function, a variable, a type, or several other things. I think there might be 6.
<verisimilitude>
The idea, rritoch, is that a symbol has a name, a home package, a function, a value, and a property list; usually, a symbol is only bound as a function or a value and the property list is typically unused.
<rritoch>
aeth: In one package you can't have a macro and a function with the same symbol, but you can have a function and a variable with the same symbol, right?
<verisimilitude>
Yes.
<rritoch>
verisimilitude: Ok, so you are saying that a package only contains symbols, but the symbol contains a value (possibly undefined) and a form (either function or macro and can be undefined)
asarch has quit [Quit: Leaving]
<aeth>
rritoch: The third that is commonly seen is types (e.g. deftype). I think types and classes share a namespace, and a class (either standard-class in defclass or structure-class in defstruct) creates a type. I think the distinction is that types can include more than just classes, such as (integer 0 5)
nicdev has quit [Ping timeout: 246 seconds]
<aeth>
(i.e. I think that types are just a superset of classes.)
<verisimilitude>
Yes, rritoch; I've explained the different components of symbols earlier.
<aeth>
verisimilitude: By "two kinds of namespaces" I mean the type-based namespace (if that's the correct way to refer to it) and the package-based namespace. The former is often called Lisp-2 but that's more than two.
<verisimilitude>
Okay.
<rritoch>
aeth: So a package:symbol can have a function and a class/type ?
<verisimilitude>
You know how to use DESCRIBE and INSPECT, right, rritoch?
<rritoch>
verisimilitude: Its been awhile, but I've used it before.
<aeth>
rritoch: Symbols, which have a name and a package (and can be internal-only in that package) can have a function/macro, a class/type, a variable, and a few other things that I can't find right now. Symbols also have a plist, which is a separate feature that is rarely used in modern Lisp code.
<aeth>
I think conditions might be independent of classes/types, but I'm not sure.
<verisimilitude>
I suggest you take a look at these symbols: +, NULL, and INTEGER.
<verisimilitude>
These are some symbols used in multiple ways and you may find it educational to take a look at them.
shifty has quit [Ping timeout: 268 seconds]
<rritoch>
aeth: verisimilitude: Thank you very much :) The answer was far more complicated than I expected but it gets me forewards
<aeth>
It looks like conditions use the same namespace as classes and types. e.g. (define-condition foo (error) ()) then (defclass foo () ()) then (deftype foo ())
<aeth>
Once I do the first in SBCL the 2nd is an error and the 3rd is a warning
<rritoch>
I'm starting a new open source project to build a common lisp interpreter that is fully fused in python (no external lisp interpreter)
<verisimilitude>
Common Lisp is a nice language, but it is also a large language, although still small compared to Python, Java, C++, et al.
<verisimilitude>
I don't believe conditions are required to do that, aeth.
<no-defun-allowed>
really
<no-defun-allowed>
i thought conditions were CLOS instances
<aeth>
verisimilitude: It's definitely possible that it's UB
<verisimilitude>
There's that WITH-SLOTS warning and all of that.
<aeth>
That's good enough to treat them as the same namespace for practical purposes, though. As in, don't get conflicts in certain implementations.
<verisimilitude>
So, conditions can be the same classes, but I don't believe they're required to.
<no-defun-allowed>
true, the CLHS really wants you to use the condition-specific interfaces
<aeth>
verisimilitude: Yes, but the question is if they are in the same *namespace* as classes.
<verisimilitude>
Oh, yes; you'd need to account for it, sure.
<Bike>
condition types don't have to be classes but you can't have a class and a condition type with the same name
<aeth>
Bike: Do you know if there are namespaces separate from functions/macros, variables, and types/standard-classes/structure-classes/conditions? I tried looking around the HyperSpec but I can't find it.
<Bike>
compiler macros, sort of.
<Bike>
and method combinations.
<fiddlerwoaroof>
Other things too
<fiddlerwoaroof>
restarts, tags, blocks(
<fiddlerwoaroof>
clhs namespace
<specbot>
Couldn't find anything for namespace.
<aeth>
ah, yes, I forgot about tags.
<fiddlerwoaroof>
anyways, as the glossary says:
<fiddlerwoaroof>
1. bindings whose denotations are restricted to a particular kind. ``The bindings of names to tags is the tag namespace.''
<aeth>
fiddlerwoaroof: That will just take you to the glossary, not a page that lists them
<aeth>
I went around in circles in the glossary for a while, only going to other related glossary entries
<fiddlerwoaroof>
Yeah, I wanted the definition
<Bike>
oh, i was thinking globally i guess.
<aeth>
Bike: same
<verisimilitude>
Symbol macros also came to mind earlier as an important note.
rk[ghost] has quit [Ping timeout: 246 seconds]
<fiddlerwoaroof>
Anyways, I'm not sure that "namespace" is a particularly precisely-defined term
<fiddlerwoaroof>
I'd be inclined to say that there are an indefinite number of namespaces because a programmer can use a symbol as an identifier for anything they please
<aeth>
fiddlerwoaroof: Seems pretty precise to me. There are two kinds of namespaces: packages, which namespace the symbols, and binding namespaces, which are based on the "particular kind" (I guess because they're not technically types?)
rk[ghost] has joined #lisp
<fiddlerwoaroof>
Yeah, I guess I was thinking that the term has indefinite extent
<aeth>
fiddlerwoaroof: Short of implementing your own bindings via objects or hash tables, you'd really be using some other binding, with its particular namespace.
<fiddlerwoaroof>
Sure, but the point is you can implement your own bindings
<fiddlerwoaroof>
I mean, the class namespace is just that
<fiddlerwoaroof>
There's some standardized syntactic sugar for referring to class metaobjects indexed by symbols
<fiddlerwoaroof>
But packages like optima/trivia add things like a "matcher" namespace
<aeth>
fiddlerwoaroof: Even if you count custom bindings, you can still set a lower bound for n in Lisp-n, which is clearly more than 2 (as I said earlier, 3 are very common). Of course, a program could add to that n.
<fiddlerwoaroof>
yeah
<aeth>
Really impossible to avoid adding features to a language with both Lisp-style macros and reader macros
<aeth>
s/to avoid adding features/to avoidt he ability to add features/
<rritoch>
Next question. Say I want an implementation of common lisp (possibly with small standards compliance violations) with resource limitations such throwing an error if a loop has been running for more than 5 minutes. Has something similar ever been achieved? Ideally I want a system that can run untrusted code in a sandbox with no risk of crashing the environment.
Oladon has quit [Quit: Leaving.]
<fiddlerwoaroof>
rritoch: it's possible to do that sort of thing using interrupt-thread and stuff
<verisimilitude>
You could hack something together using timers and BORDEAUX-THREADS, rritoch.
<fiddlerwoaroof>
The bigger issue, though, is preventing access to unsafe functions: you'd need a safe reader and custom logic for figuring out how to resolve uninterned symbols to a "safe" set of symbols.
<fiddlerwoaroof>
There's also research on languages that can be safely execute untrusted code
<fiddlerwoaroof>
But you'd have to write your own eval for that
<verisimilitude>
Use GET-INTERNAL-REAL-TIME.
<aeth>
What I usually do is not even control the loop in the thing being looped, and instead just tick up a counter. Obviously, it's imperfect if there's an infinite loop within the thing, so perhaps a combination is the best way (do it by ticks so one greedy loop doesn't take too much time, but also kill the individual iteration if it takes too long).
<fiddlerwoaroof>
You can have an EVAL with a verified-safe set of special forms and a "fuel" that ticks down every time a function is called
<aeth>
I find it's easier to work with a "tick" system than with real real-time. e.g. Start at 0 and increment every 10 ms or something.
<fiddlerwoaroof>
Then, when the fuel ticks below 0, abort
<rritoch>
I'm not actually coding right now. I'm setting up specifications for an open source project to create a lisp interpreter that runs in python and is fully fused with python.
<fiddlerwoaroof>
That will guarantee a max running time of your longest-running special form * fuel
<aeth>
rritoch: You might find it's easier to go the other way around and implement a Python interpreter in Common Lisp.
<fiddlerwoaroof>
rritoch: you might also look at stuff like Dhall that give up Turing-completeness in order to make it safe to evaluate arbitrary code
<rritoch>
But running untrusted code has been something I've always wanted to do, since my days coding MUD's in LPC
<rritoch>
aeth: That's already been done
<fiddlerwoaroof>
Yeah, there's clpython
<fiddlerwoaroof>
that still kinda works
<rritoch>
aeth: But its not an option because I need low-level python capabliities, such as GPU acceleration, and in the future Quantum Computing.
<verisimilitude>
You can easily run untrusted code; simply defang it.
<fiddlerwoaroof>
rritoch: there's also things like burgled-batteries that use real python code
arav has joined #lisp
<verisimilitude>
There's nothing reasonable a properly written 6502 emulator, say, can do to break into the greater system.
<aeth>
rritoch: Yes, but CL is a fairly low level language. You can do things like JSCL but then you wind up having to disable features (and it would have to do so even if JSCL was a complete implementation of the part specified in the CL spec). So you can get a CL, it's just not a particularly sastifying one unless you have no choice (which it sounds like you might not have)
<fiddlerwoaroof>
CL isn't really a low-level language :)
<fiddlerwoaroof>
It's a multi-storied language
<fiddlerwoaroof>
Some people work in the basement while others work in the attic
<aeth>
fiddlerwoaroof: The only thing high level that is essentially forced on you is a GC. But yes, it's multi-storied.
<rritoch>
aeth: I'm with fiddlerwoaroof: on this one! I would argue that there is no language that is higher-level than lisp
<fiddlerwoaroof>
Macros and CLOS give you much more flexibility than js/python/etc.
<rritoch>
aeth: Its my understanding that you can technically interpret any language in CL
<fiddlerwoaroof>
rritoch: that's just Turing completeness, though
<rritoch>
aeth: Can't get much higher level than that
<aeth>
Of course, the failure of fifth-generation programming languages as a thing probably makes CL seem high level.
<aeth>
These days we'd probably just call the languages "declarative". I used the intentionally archaic term because CL was designed in that era.
<fiddlerwoaroof>
Really, I think the high/low-level distinction is a better fit for things like Python and C where you can't (realistically) work at all levels in a single language
<fiddlerwoaroof>
CL is more like a unix shell that's also a decent systems programming language as well as a decent scripting language.
pierpal has joined #lisp
<fiddlerwoaroof>
It might not always be the most efficient/performant for any given task, but it can generally do a decent job at almost anything you throw at it.
<fiddlerwoaroof>
And when you run into boundaries, there's things like CFFI that are almost unimaginable in any other language
<fiddlerwoaroof>
(outside the JVM, I guess)
<verisimilitude>
Comparing CL to sh is like comparing a gun to a gun wound.
<aeth>
CL is basically in the same class/niche of languages as Java or C# even though CL is normally AOT-compiled.
<fiddlerwoaroof>
What I meant isn't that it _is_ a unix shell, but you can almost use it as a login shell without missing anythign
<verisimilitude>
Well, I do my ``scripting'' with it. Unlike sh, I can easily write a program that actually works with it.
<fiddlerwoaroof>
When I'm working on CL stuff, I use quickload for the sort of things that I use apt/brew for in osx
undiscovered has quit [Remote host closed the connection]
<aeth>
verisimilitude: At least in SBCL with safety above 0.
<verisimilitude>
There's no similar ``This filename contains a space or a newline or a tab.'' misdesigns.
<fiddlerwoaroof>
And the CL environment is almost self-sufficient
<aeth>
I'm only really confident in my programs in SBCL.
<fiddlerwoaroof>
verisimilitude: I see you haven't worked with pathnames much ;)
<verisimilitude>
I have, fiddlerwoaroof.
pierpal has quit [Ping timeout: 240 seconds]
<rritoch>
Well, I see "high-level" as being more data than code. Something thats modular and can be easily changed in real time. You can use LISP in place of JSON {'foo' : 'foovalue'} => (("FOO" . "FOOVALUE"))
<verisimilitude>
It's very simple for me to write file-manipulation code in CL; sh is a minefield and I refuse to use it.
<fiddlerwoaroof>
It's fairly difficult to write certain filenames in a portable fashion, without using something like UIOP
<djeis[m]>
Pathnames on SBCL are nice and convenient.
<verisimilitude>
What do you mean, fiddlerwoaroof?
<djeis[m]>
I really like them.
<verisimilitude>
I use MAKE-PATHNAME for the names and all of that.
<djeis[m]>
But very little of the pathnames API is actually portable.
<aeth>
I can't really say I write portable CL, I can only say that I haven't discovered non-SBCL issues yet.
<fiddlerwoaroof>
I forget the details, but there are issues when your filename has more than one dot in it, for example
<rritoch>
Only a masochist would use C, Python, or Ruby as a data format.
<fiddlerwoaroof>
SBCL mostly "just works" but CCL won't necessarily work
<verisimilitude>
There can be, sure, and I simply try to take it into account when writing the programs.
<fiddlerwoaroof>
And CCL still, afaict, behaves in a conformant fashion.
pierpal has joined #lisp
<aeth>
I use UIOP for pathname stuff
<djeis[m]>
The actual contents of the :directory component of a pathname aren't, technically, even specified IIRC.
<aeth>
This channel recommends that, and I guess it makes sense. Any issues will probably be discovered through ASDF itself.
<fiddlerwoaroof>
Yeah, that's what I basically landed on
<djeis[m]>
Implementations can stick basically anything in there.
<verisimilitude>
Also, for throwaway programs, it's not even an issue, which I'd figure much of ``scripting'' falls under.
<djeis[m]>
And SBCL does, for example, when you make a pathname like #p"~/*foo/qwer.lisp"
<djeis[m]>
That directory component contains a special wildcard component, if memory serves, that explicitly notes that it's wild in part of the directory name.
<djeis[m]>
Yea for throwaway SBCL-specific programs it's nice and convenient.
<aeth>
What's fun about a natively compiled CL is that you can basically go as low as you want to go. Just use some very high level libraries (including some of alexandria's APIs like curry/rcurry) or disassemble and try to get exactly the asm you want
<aeth>
I think that really just applies to SBCL and CCL, though.
<djeis[m]>
I love the pathnames system in principle, and when I get to be SBCL specific I love it in practice, but only portable at a very surface level.
<fiddlerwoaroof>
I think the commercial lisps have similar stuff aeth
<djeis[m]>
*but it is only
<verisimilitude>
It's also nice how DISASSEMBLE is present; you can view a function easier than you can in the supposedly low-level languages.
<aeth>
fiddlerwoaroof: well I write assuming 64-bit and the commercial Lisps charge for that so I have 0 experience with them
<djeis[m]>
Yea DISASSEMBLE basically takes the place of something like godbolt's compiler explorer.
<aeth>
fiddlerwoaroof: I'll also never support them in my libraries unless they send me a copy (even if the copy's restrictions are simply that I can only use them for writing my libraries)
* fiddlerwoaroof
wishes there was a trivial-assembler library that provides a portable interface to the implementation's code generators
<fiddlerwoaroof>
aeth: I have a LW license and, for the most part, libraries just work
pierpal has quit [Ping timeout: 272 seconds]
<fiddlerwoaroof>
Every once in a while I complain on someone's issue tracker, though :)
<aeth>
fiddlerwoaroof: the thing is, if I can't reproduce it it's not a bug
<fiddlerwoaroof>
Well, it's usually useful because it reveals non-conforming behaviors
<aeth>
Yes, definitely, if it's non-conforming behavior it can be fixed. But if it's #+acl or something, there's no way I can maintain that even if it works at the moment of the patch.
<fiddlerwoaroof>
Also, it's kinda annoying, but CAPI/LW is the easiest idea->reality way to write GUIs
<fiddlerwoaroof>
yeah, I generally don't do that sort of thing
<fiddlerwoaroof>
It's more things like it's better to do #\U+2203 than #\SOME-CHARACTER-NAME
* djeis[m]
wishes I could seriously recommend McClim, resets my timer to check in on it for another month or so
Bike has quit [Ping timeout: 256 seconds]
<fiddlerwoaroof>
djeis[m]: on Linux, Mcclim is pretty good
<djeis[m]>
Oh yea, it is. I enjoy tinkering with it.
<fiddlerwoaroof>
It's definitely a lot nicer to work with at an API-level than anything else
<djeis[m]>
Still needs more than a little polish before I'd recommend it lol
<fiddlerwoaroof>
And making every pane a stream is quite ingenious
<djeis[m]>
Agreed ^^
<aeth>
djeis[m]: Your best bet is probably to do a Blender-style GUI in OpenGL. Of course, it works in Blender because you can assume that someone doing 3D modeling is going to have good 3D drivers/hardware.
<djeis[m]>
There are a lot of brilliant ideas in Clim.
<fiddlerwoaroof>
Incidentally, I've been working on something similar for SLIME
<aeth>
mcclim had an OpenGL backend but it was like 20 or so years out of date when it was removed!
<djeis[m]>
Yea but like.... I neither want to reimplement imgui nor wrap it.
<fiddlerwoaroof>
I really kinda want to develop this to a point where I can write an Emacs clim backend :)
<djeis[m]>
That would certainly be interesting.
<fiddlerwoaroof>
Emacs already has font-lock which can be used for dynamic text styling (I think)
<fiddlerwoaroof>
And then there's the widget library that customize/etc. uses
<aeth>
djeis[m]: You could try implementing a mcclim backend in cl-opengl + cl-sdl2 (or some other window/input library that gives cl-opengl what it needs).
<djeis[m]>
There's the CLDK backend which uses SDL.
<aeth>
The most mature graphical interface into FOSS CLs is OpenGL
<djeis[m]>
And it's more or less functional.
<djeis[m]>
Although it's relatively slow.
<djeis[m]>
And 3rd party.
<fiddlerwoaroof>
Hmm, I have some objective-c bindings
pierpal has joined #lisp
<fiddlerwoaroof>
In theory it would be possible to write a Gnustep/OSX backend
<djeis[m]>
Should be, yea.
<fiddlerwoaroof>
Of course, Gnustep isn't the most lively project around
<djeis[m]>
Also true lol
<fiddlerwoaroof>
But Objective-C is actually fairly pleasant to interface with from CL
<fiddlerwoaroof>
Because of its Smalltalk roots
<djeis[m]>
Cool
<fiddlerwoaroof>
I've been doing a lot of Applescript-style things on my mac
pierpal has quit [Ping timeout: 240 seconds]
pierpal has joined #lisp
pierpal has quit [Ping timeout: 268 seconds]
pierpal has joined #lisp
pierpal has quit [Ping timeout: 245 seconds]
pierpal has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
smokeink has joined #lisp
pierpal has quit [Ping timeout: 268 seconds]
hvxgr_ has joined #lisp
hvxgr_ has quit [Client Quit]
Lord_of_Life has quit [Ping timeout: 246 seconds]
hvxgr has quit [Quit: leaving]
Lord_of_Life has joined #lisp
wigust- has joined #lisp
esrse has joined #lisp
wigust has quit [Ping timeout: 268 seconds]
<rritoch>
Stupid grammar question, what is the formal name of CL "Common lisp", "Common Lisp", "Common LISP"
arav has quit [Ping timeout: 256 seconds]
<edgar-rft>
Common Lisp
<rritoch>
edgar-rft: ty
hvxgr has joined #lisp
pierpal has joined #lisp
nicdev has joined #lisp
quazimodo has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
jinkies has quit [Remote host closed the connection]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
akoana has left #lisp ["Leaving"]
nicdev has quit [Ping timeout: 272 seconds]
pierpal has quit [Ping timeout: 240 seconds]
pierpal has joined #lisp
<LdBeth>
well, it's Computational Logic :D
akoana has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
akoana has left #lisp [#lisp]
pierpal has joined #lisp
atgreen has quit [Ping timeout: 246 seconds]
quazimodo has quit [Read error: Connection reset by peer]
atgreen has joined #lisp
rk[ghost] has quit [Ping timeout: 245 seconds]
pierpal has quit [Ping timeout: 250 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
rk[ghost] has joined #lisp
pierpal has joined #lisp
wanz has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
<beach>
Good morning everyone!
<beach>
shka_: The book is highly regarded. I have mixed feeling, as I do with most textbooks in computer science.
atgreen has quit [Remote host closed the connection]
atgreen_ has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
Oladon has joined #lisp
atgreen__ has joined #lisp
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
atgreen_ has quit [Ping timeout: 245 seconds]
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<rritoch>
I'm seriously considering previous suggestions though that python just be used to bootstrap it and have the actual implementation in LISP source code
<rritoch>
Right now I'm not even close to that point.
<beach>
rritoch: What do you expect the advantages of your interpreter to be compared to other Common Lisp implementations?
iovec has quit [Quit: Connection closed for inactivity]
<rritoch>
The advantage is to extend python to include common lisp code that can natively call python code.
<beach>
OK.
<beach>
It sounds to me that it will be very very slow.
<rritoch>
Yes, I suspect it will be
<beach>
Already Python is slow. Much slower than most modern Common Lisp implementation.
<rritoch>
There's little advantage for LISP apps, but a lot of advantage to python apps.
<beach>
But then you want to write an interpreter (as opposed to a compiler) to run the Common Lisp code.
<rritoch>
Not exactly
<rritoch>
Do you know python?
<beach>
A little bit.
<LdBeth>
I think if using PyPy as backend will have satisfiable performance
<rritoch>
It locates the function from the environment, and executes it directly
<rritoch>
Ideally the end product would be fullly implemented in python, but since that is an insanely huge project, simply getting it to the point where it could bootstrap an existing impelmentation written in LISP should be enough.
<beach>
OK. Good luck.
<rritoch>
performance wise I suspect it will be about 4X slower than python, unless someone gets greedy and decides to accelerate it with some c libraries :)
<no-defun-allowed>
libecl?
<rritoch>
beach: Thanks. Right now I'm mostly just using it for a few small things as it isn't fully functional, but I hope it will one day become fully functional.
iAmDecim has joined #lisp
<beach>
rritoch: At least you will learn lots of things and that's good.
atgreen__ has quit [Ping timeout: 268 seconds]
<LdBeth>
I would say source to source transformation is more reasonable than interpreting
<rritoch>
beach: Yes, I just hope I don't run out of storage space, lol. I've been coding for like 36 years, sometimes I worry I'm running out of storage space. 90% of what I've learned is no longer relevant.
<rritoch>
Example, being able to code assembly language on a Apple II is somethign that I haven't used in over 26 years
<rritoch>
I have the worst luck, the only technology I ever learned that is still relevant, is lisp.
quazimodo has quit [Read error: Connection reset by peer]
<rritoch>
It seems to me that Ruby and Java are declining, Python is picking up, but Common Lisp seems to maintain relevance, or it simply grows at a slow pace.
<rritoch>
10 years from now I'm quite sure all my Ruby, Java and Python code will be useless, but the Common Lisp code will still run.
meiji11 has quit [Remote host closed the connection]
<beach>
rritoch: So why concentrate on a Common Lisp implementation written in Python rather than one of the excellent existing Common Lisp implementations?
quazimodo has joined #lisp
<rritoch>
beach: Development speed
<beach>
I don't understand.
<LdBeth>
^ what does python have that CL doesn't?
permagreen has joined #lisp
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
<rritoch>
LdBeth: I have no idea, I've literally only been programming in python professionally for about 2 months. I did most of my previous work in Java and even made my own fork of ABCL to make it pass all of the ANSI tests.
<rritoch>
There's no equivalent of ABCL in Python
<rritoch>
LdBeth: I can tell you that Java has more available freelancers than common lisp.
<rritoch>
LdBeth: I suspect python does also
<beach>
rritoch: "development speed" between what and what?
<rritoch>
beach: Between modifying a completely functional system, and building an entirely new one in CL
serichsen has quit [Ping timeout: 252 seconds]
themsay has quit [Ping timeout: 246 seconds]
themsay has joined #lisp
<beach>
I still don't understand, but it's not that important.
gravicappa has joined #lisp
themsay has quit [Ping timeout: 250 seconds]
Oladon has quit [Quit: Leaving.]
Necktwi has joined #lisp
Tristam has quit [Remote host closed the connection]
pierpal has quit [Quit: Poof]
Tristam has joined #lisp
pierpal has joined #lisp
quazimodo has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
can CL compilers utilise SIMD extensions like SSE?
<beach>
Sure.
<beach>
I think SBCL does in some situations.
<djeis[m]>
SBCL has support for the instructions, but I have yet to see it actually make use of them ootb.
themsay has joined #lisp
<djeis[m]>
Libraries have been written with explicit SBCL extensions to have it generate SSE code tho.
<no-defun-allowed>
i imagine a compiler could fold something like (map '(simple-array double-float (*)) #'+ a b) into some SSE code
<no-defun-allowed>
is there any documentation on writing SBCL compiler intrinsics like that?
<fiddlerwoaroof>
no-defun-allowed: not really, but there are some relevant posts on pvk.ca
<aeth>
I suspect that the simple issue is that it's too hard.
dddddd has quit [Remote host closed the connection]
<aeth>
You'd probably have to hire someone to work on it or crowdfund them
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
meepdeew has joined #lisp
dale has quit [Quit: dale]
orivej has joined #lisp
_whitelogger has joined #lisp
iskander has quit [*.net *.split]
gko has quit [*.net *.split]
galdor has quit [*.net *.split]
voidlily has quit [*.net *.split]
abbe has quit [*.net *.split]
physpi has quit [*.net *.split]
rme has quit [*.net *.split]
capadoodle has quit [*.net *.split]
ede has quit [*.net *.split]
abbe has joined #lisp
rme has joined #lisp
voidlily has joined #lisp
iskander has joined #lisp
physpi has joined #lisp
gko has joined #lisp
zotan has quit [Ping timeout: 246 seconds]
galdor has joined #lisp
zotan has joined #lisp
mange has quit [Ping timeout: 246 seconds]
makomo has joined #lisp
themsay has quit [Ping timeout: 245 seconds]
themsay has joined #lisp
<fiddlerwoaroof>
My brain's not working right now, what's a predicate that tells me whether an object is an instance of a particular class?
<fiddlerwoaroof>
I guess typep?
<beach>
Yes.
<beach>
Or, or if you want the immediate instance, (eq (class-of object) (find-class ...))
themsay has quit [Ping timeout: 244 seconds]
themsay has joined #lisp
<fiddlerwoaroof>
No, this is just for a sanity-check assertion
<fiddlerwoaroof>
I'm using a library that fails spectacularly if I accidentally feed it a string instead of an instance of one of its classes, so I'm putting an ASSERT in
zmt00 has quit [Read error: Connection reset by peer]
marvin2 has joined #lisp
<fiddlerwoaroof>
And, now I realize I should just CHECK-TYPE
zmt00 has joined #lisp
<margaritamike>
what does an & next to a parameter for a function in documentation mean for lisp?
<shka_>
loke: few data-structures with common interface, including functional dictionaries, functional vectors, functional quoues plus protocol for Java 8-like streams
<shka_>
and some functions that work on those ranges
<shka_>
aggregators and so ones
<loke>
shka_: Interesting
<shka_>
writing it was interesting as well
<loke>
I built one like that myself, but it's not very good. _however_ it does contain what I believe is the only correct implementation of read-black-trees in Common Lisp.
<loke>
Would you like to merge that code into your library?
<loke>
red-black
<shka_>
thanks to CLOS writing stuff like group-by was pretty cool
wanz has quit [Quit: wanz]
<loke>
red-black trees are notoriously hard to get right
<shka_>
loke: ideally, yes, but i would have to find some time for that, and i am already committed to make few other things
<shka_>
like making merge sort for SICL
<shka_>
which turns out to be frustraiting affair ;-)
quazimodo has joined #lisp
<loke>
I'd really like my version to somehow make it only Quicklisp, as the other two available versions are buggy
<shka_>
if you want to contribute, i am more then accepting merge requests ;-)
<loke>
(I had an application that hit the trees very heavily and both those versions tends to lose elements in some edge cases)
<shka_>
well, that sounds badly
<fiddlerwoaroof>
loke: in theory you could package it up and implement some other library's interface
<fiddlerwoaroof>
fset, I believe, is sort of designed to be extended that way
<loke>
shka_: Yes. The test cases for my implementation specifically tests for the cases where I discovered the others to fail.
<loke>
I have no idea to to minimise the test case. I found it by recording production dataunil I had a crash and then found a sequence of adds and removes that lost elements.
<shka_>
currently i have no ordered dictionary of any kind in the cl-ds so i may eventually want to include this
<shka_>
just not soon
<loke>
(I also have two similar bugs in my implementation, caused by subtle typos in my transformation of the original C code). What's really annoying is that when you get something wrong it works for all obvious test cases, but will fail in some edge cases.
<fiddlerwoaroof>
that's quite a test case...
<loke>
Anyway, this version has been battle tested and seems to be correct.
wanz has joined #lisp
<loke>
Tell me about it... have a look at this monster. :-)
<loke>
But red-black trees depend on mutating the elemtns, no?
<loke>
shka_: Good call :-)
<verisimilitude>
It's always impressive when I see a particluarly ugly URL.
<loke>
and that's also why I'd like mine to be more available.
<shka_>
loke: i have mutable and functional stuff
<shka_>
and some weird hybrid between those two to help implementing lazy evaluated stuff
<fiddlerwoaroof>
the intersting page is missing...
scymtym has quit [Ping timeout: 246 seconds]
quazimodo has quit [Ping timeout: 250 seconds]
xkapastel has joined #lisp
q3d has joined #lisp
gxt has quit [Quit: WeeChat 2.3]
wanz has joined #lisp
space_otter has joined #lisp
JetJej has joined #lisp
scymtym has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
Lycurgus has joined #lisp
wanz has quit [Quit: wanz]
Lycurgus has quit [Quit: Exeunt]
atgreen__ has joined #lisp
Lycurgus has joined #lisp
Lycurgus has quit [Remote host closed the connection]
orivej has joined #lisp
tempate has quit [Ping timeout: 264 seconds]
antoszka has quit [Quit: WeeChat 2.1]
Lycurgus has joined #lisp
Lycurgus has quit [Quit: Exeunt]
JetJej has quit [Quit: [Quit]]
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
wanz has joined #lisp
marvin2 has quit [Ping timeout: 272 seconds]
Kaisyu has joined #lisp
antoszka has joined #lisp
wanz has quit [Quit: wanz]
m00natic has joined #lisp
iAmDecim has quit [Ping timeout: 245 seconds]
gravicappa has quit [Ping timeout: 250 seconds]
<beach>
Speaking of data structures, I am collecting different versions of the standard binary search algorithm as published in various text books. So if you have a text book on algorithms that contains a version of binary search, I would like a copy of it (the algorithm, not the book) and the name of the book.
<beach>
The one is Aho, Hopcroft, and Ullman takes twice the time that it should, for instance.
<flip214>
beach: do you take photos as well?
<beach>
Sure.
<shka_>
beach: why it takes twice the time?
<dim>
beach: would you be game to review what PostgreSQL is doing in that area? It's C code, but well commented and with references to original papers and algos when they've been implemented from papers
<shka_>
excessive use of comparsion?
<shka_>
beach: binary search limited to the simply ordered vectors, or also pointerless trees?
<jackdaniel>
I've read "pointless trees" and I like this name. I call dibs
<shka_>
how silly
<beach>
shka_: Because it test for equality with the middle element first.
<shka_>
beach: ok, this is well known
<beach>
Yes.
<beach>
But I am writing a chapter in a book about it.
<beach>
shka_: Just sorted vectors.
<shka_>
ok
<shka_>
though this algorithm is probabbly the worst case for the cache possible
salva has quit [Remote host closed the connection]
<beach>
I also checked Sedgewick & Flajolet. It is wrong too.
<shka_>
i wonder how wrong version of this algorithm could become so widespread
<beach>
It was done by theoreticians who only care about asymptotic complexity.
<beach>
And then, it has been propagated from professor to student over many generations.
<beach>
flip214: Sure, though that's not the subject of the current investigation.
salva has joined #lisp
<beach>
Anyway, time for a break.
<flip214>
beach: sorry, the algorithms book I have doesn't include Binary Search.
<beach>
No problem. Thanks for trying.
salva has quit [Remote host closed the connection]
<flip214>
you're welcome!
scymtym has quit [Ping timeout: 268 seconds]
amerlyq has joined #lisp
wanz has joined #lisp
robdog_ has quit [Remote host closed the connection]
slyrus2 has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
slyrus1 has quit [Ping timeout: 245 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
ggole has joined #lisp
nopolitica has joined #lisp
marvin2 has joined #lisp
scymtym has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
<dim>
mmm, what are the subtelties of #+pgloader-image and such wrt to compiling code to a binary image?
<dim>
I've been using that to have interactive error handling in the REPL but backtraces when /usr/bin/pgloader is run, and now I realize it doesn't work like I want, or at all
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
kushal has quit [Remote host closed the connection]
scymtym has joined #lisp
makomo has quit [Ping timeout: 268 seconds]
<beach>
dim: Sure, I'll look at it if you point me to the source code. I have programmed in C so I should be able to understand it.
anewuser has joined #lisp
<beach>
dim: Otherwise, it is quite simple. If there are two tests per iterations, the first one testing for equality, then it is wrong.
<dim>
I though that searching in binary tree would account for binary search, sorry, realizing the mistake now
<beach>
OK.
<dim>
Postgres just uses bsearch() and has its own sorting facilities (with abreviated keys in cases), but I don't think it has its own binary search actually
<beach>
Yeah, it would be surprising now that I think about it.
kushal has joined #lisp
<dim>
well PostgreSQL is quite a good example of Greenspun's law
<dim>
and yeah it's used *a lot* in the rest of the source code, mainly the parser/optimizer
<beach>
Depressing, really.
smokeink has quit [Remote host closed the connection]
<dim>
the history of it makes it a little better, I think: PostgreSQL optimizer is known to have been written in Lisp in the 80s, but then they switched to C like the rest of the system and they did that pg_list.h implementation to help with the porting
<beach>
Oh, and they even included the stuff that Common Lisp had to include for historical purposes, i.e. that the CAR and the CDR of NIL is NIL.
<dim>
then it works well enough that it never improved from there, I suppose
<shka_>
it was ingres back in the 80s
<dim>
The Postgres project started in 1986 IIRC my readings about it
<dim>
by then it was a university project by Stonebreaker and mainly used to host PhD thesis, up to 1995
<dim>
anyway, Postgres has some lisp history and pg_list.h to show for it
<beach>
I see.
smokeink has joined #lisp
<dim>
ok I'm not sure why yet but it seems that #+pgloader-image isn't defined in the image I'm using, for some reasons
<dim>
I'm doing (push :pgloader-image *features*) in src/hooks.lisp that I don't load with ASDF, but manually in the command line (using --load) when building the image, but maybe that feature is needed at compile time? read time?
ede has joined #lisp
atgreen__ has quit [Ping timeout: 250 seconds]
bendersteed has joined #lisp
dddddd has joined #lisp
bendersteed has quit [Client Quit]
Lycurgus has quit [Quit: Exeunt]
<dim>
ok read-time of course, tweaked my Makefile and buildapp usage to make it work
<Demosthenex>
so i was tinkering with reading some machine generated text (https://bpaste.net/show/eb139faf9503) i wanted to throw into a table for searching. i could do this with regexp only, but given i have a variety of outputs to look at i was considering a lexer and parser. i found alexa, but cl-yacc seems to be all over. sound like the right tool? what's the right cl-yacc home?
Essadon has joined #lisp
atgreen__ has joined #lisp
ealfonso has quit [Disconnected by services]
<beach>
Demosthenex: There are plenty of parser libraries for Common Lisp. One is esrap that is maintained by scymtym. He might know more about the subject.
<Demosthenex>
beach: yeah, i was reading about a few on cliki, but all the links to google code are dead
<shka_>
Demosthenex: also i find monadic parser combinators to be interesting and easy to use
<Demosthenex>
i haven't used a lexer/parser since cs classes in school years ago. i just thought that given the regularity of my input data that regexp for each one was a waste of time if lex/parse could do it faster.
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 250 seconds]
Lord_of_Life_ is now known as Lord_of_Life
smokeink has quit [Ping timeout: 244 seconds]
sloanr has joined #lisp
<LdBeth>
Demosthenex: actually for this kind of text you shown you’d better use awk like tools rather than parser gen
<LdBeth>
Cause strictly it’s table rather than BNF
<LdBeth>
Btw, scsh has a very impressive awk macro
kajo has quit [Ping timeout: 250 seconds]
sjl has joined #lisp
<Demosthenex>
LdBeth: that's an interesting assertion. i generally have used shell tools like awk to pull out that data, i was trying to make it a bit more formal/flexible to load into postgres, and since i was already using postmodern ;]
sjl_ has joined #lisp
Lycurgus has joined #lisp
devon has quit [Ping timeout: 250 seconds]
<Demosthenex>
i think the key difference is i've used awk for line operations instead of longer paragraph records and data extraction.
slyrus has joined #lisp
slyrus2 has quit [Ping timeout: 246 seconds]
<dim>
Demosthenex: maybe you can implement ELT rather than ETL
<dim>
Load the data in PostgreSQL then process it in SQL, that's very flexible and powerful, and you have advanced and fast support for data processing
<Demosthenex>
dim: i only ever insert finished data into sql... do you have a link to an example?
nowhere_man has joined #lisp
<dim>
use COPY to load the data quickly, then process it, I think I have many examples of that on my blog
<Demosthenex>
well, i understood loading the raw text in. i just hadn't considered parsing the text to extract useful information inside sql... i was leaning on lisp for that
<Demosthenex>
you have a link on your blog?
m00natic has quit [Remote host closed the connection]
<dim>
tapoueh.org
<dim>
trying to find the most relevant article for you now
<dim>
then my book has many examples of doing that in different ways, but well
m00natic has joined #lisp
<Demosthenex>
i hope in your book you say "using multiline regexps to try and match data is a bad idea" ;]
<Demosthenex>
hrm. i see the group by a replaced string, but that's not the actual record extraction. you're extracting from xml
<dim>
the idea is that you can do most of your processing directly in SQL
<dim>
I should write a better article about that really
<dim>
I've been doing that a lot, and I though I had the idea covered better on the blog, because I have lots of articles where I though I would explain that, turns out I did the job to prepare the data and that's usually not the topic of the blog post
<dim>
anyway, either filter on the fly with CL and use Postmodern support for the COPY streaming protocol (see cl-postgres:db-write-row and friends and an example at https://github.com/dimitri/pubnames/blob/master/pubnames.lisp); or just load a CSV-like input file and then process in SQL, that's the easiest way to do it, mainly because then the input data and their transformations are well defined
guicho has quit [Remote host closed the connection]
Bike has quit [Ping timeout: 256 seconds]
Mr-Potter has joined #lisp
Bike_ is now known as Bike
<Lycurgus>
looking for van wijngaarden grammar based parse in cl, will check log for any replies, ty in advance
<Lycurgus>
*parser
<Lycurgus>
or more likely parser generator, cl-yacc variant, etc.
Lycurgus has quit [Quit: Exeunt]
anewuser has quit [Quit: anewuser]
q3d has quit [Ping timeout: 256 seconds]
beach has quit [Ping timeout: 252 seconds]
beach has joined #lisp
Bike_ has joined #lisp
Bike has quit [Disconnected by services]
Bike_ is now known as Bike
ntbre has joined #lisp
hvxgr_ has joined #lisp
hvxgr has quit [Quit: leaving]
hvxgr_ has quit [Client Quit]
sloanr has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
ntbre has quit [Client Quit]
nowhere_man has quit [Ping timeout: 268 seconds]
Oladon has joined #lisp
ntbre has joined #lisp
iovec has joined #lisp
ntbre has quit [Client Quit]
Bike has quit [Ping timeout: 256 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
hvxgr has joined #lisp
devon has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Josh_2 has joined #lisp
<Demosthenex>
i was just asking about those ;]
<Demosthenex>
dim: the filter and such sounds applicable to single row records, i'm having to collate data from a multiline record and transpose that into a single row for insertion, i don't think i can do that during a COPY
<dim>
sure you can
Denommus has joined #lisp
<dim>
that's what I'm doing in the pubnames examples, where the input format is XML key/value and with a single k/v per input line, and I'm using several values to form a single row in the COPY stream
<dim>
if you process in CL then just call db-write-row when you have all the tuple information
prxq has joined #lisp
nowhere_man has joined #lisp
akoana has joined #lisp
devon has quit [Ping timeout: 250 seconds]
scymtym has quit [Ping timeout: 250 seconds]
Denommus has quit [Remote host closed the connection]
schweers has quit [Ping timeout: 268 seconds]
Bronsa has joined #lisp
orivej has joined #lisp
Oladon has quit [Quit: Leaving.]
kajo has joined #lisp
m00natic has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 252 seconds]
varjag has joined #lisp
xkapastel has joined #lisp
vaporatorius has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
sloanr has joined #lisp
travv0 has joined #lisp
nowhere_man has joined #lisp
space_otter has quit [Remote host closed the connection]
devon has joined #lisp
vaporatorius has quit [Quit: Leaving]
ggole has quit [Quit: ggole]
scymtym has joined #lisp
nanoz has joined #lisp
igemnace has quit [Quit: WeeChat 2.3]
nowhere_man has quit [Ping timeout: 264 seconds]
Zaab1t has joined #lisp
ravenousmoose has joined #lisp
devon has quit [Ping timeout: 264 seconds]
guicho has joined #lisp
ntbre has joined #lisp
ntbre has quit [Quit: ntbre]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
amerlyq has quit [Quit: amerlyq]
makomo has joined #lisp
karlosz has joined #lisp
Mr-Potter has quit [Remote host closed the connection]
lemoinem has quit [Ping timeout: 272 seconds]
Mr-Potter has joined #lisp
Denommus has joined #lisp
devon has joined #lisp
Mr-Potter has quit [Ping timeout: 240 seconds]
Denommus has quit [Remote host closed the connection]
Jesin has quit [Quit: Leaving]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
pmc_ has joined #lisp
Jesin has joined #lisp
pmc_ has quit [Client Quit]
Denommus has joined #lisp
Selwyn has quit [Remote host closed the connection]
devon has quit [Ping timeout: 268 seconds]
guicho has quit [Ping timeout: 272 seconds]
rcosta has joined #lisp
Denommus has quit [Read error: Connection reset by peer]
rcosta has quit [Client Quit]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
gxt has joined #lisp
nowhere_man has joined #lisp
chipolux has joined #lisp
Arcaelyx has joined #lisp
sloanr has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
nopolitica has quit [Ping timeout: 245 seconds]
jack_rabbit_ has quit [Ping timeout: 268 seconds]
kajo has quit [Ping timeout: 264 seconds]
nanoz has quit [Ping timeout: 250 seconds]
jack_rabbit_ has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
Mr-Potter has joined #lisp
kajo has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
pillton has quit [Read error: Connection reset by peer]
<no-defun-allowed>
i think it's cause it uses fast-io, which uses static-vectors, which uses CFFI which doesn't load right for some reason
Essadon has quit [Quit: Qutting]
devon has joined #lisp
varjag has quit [Ping timeout: 250 seconds]
<fortitude>
no-defun-allowed: looks like CFFI is using a macro called OS-COND that hasn't been loaded
<fortitude>
not sure where that's supposed to be defined
<no-defun-allowed>
i honestly don't have a clue, my main priority is getting the buildpack to load a custom hunchentoot acceptor which isn't happening i think
<fortitude>
no-defun-allowed: maybe try explicitly depending on uiop? that's where OS-COND is from, and the CFFI-TOOLCHAIN system doesn't depend on it
<no-defun-allowed>
right
<fortitude>
uiop usually gets shipped with adsf, but it can be old
<no-defun-allowed>
i see, i did force quicklisp to try to update in the deploy script so there could be a problem
devon has quit [Ping timeout: 250 seconds]
<fortitude>
hmm, looks like cffi-toolchain depends on cffi, which in turn depends on uiop
<fortitude>
so an explicit dependency wouldn't help
<no-defun-allowed>
what i didn't see was the comment telling me where to put the toplevel function
* no-defun-allowed
is greeted by debugger going in circles
<no-defun-allowed>
well, i got the acceptor set up right, but there's still no content on the page
<fortitude>
is it returning a 404 or other error without any body content?
rk[ghost] has quit [Ping timeout: 244 seconds]
sjl_ has quit [Ping timeout: 268 seconds]
sword has quit [Remote host closed the connection]
<no-defun-allowed>
yeah, 404 with a generic "/ not found" page
<no-defun-allowed>
i can't believe people think this is a good way of hosting programs tbh
<no-defun-allowed>
how the hell do you debug this
<no-defun-allowed>
doesn't even come up with the "Hunchentoot has been installed" page
rk[ghost] has joined #lisp
<fortitude>
is that because hunchentoot's been configured not to do that, or is it because there's some kind of proxy in the middle and you aren't even hitting hunchentoot?
<no-defun-allowed>
no, it has Hunchentoot in the footer