<anniepoo>
I want to use sldb to single step through a function. How do I invoke it?
robotoad has joined #lisp
ryan_vw has joined #lisp
warweasle has quit [Quit: moo]
<pillton>
anniepoo: (break)
jack_rabbit has joined #lisp
<pillton>
anniepoo: The function you are stepping through should be compiled with the following optimize declarations: (optimize (debug 3) (safety 3) (speed (0)))).
<anniepoo>
ok, my question's perhaps too simple
<anniepoo>
I'm looking at the repl
<pillton>
Sorry, that should have been: (optimize (debug 3) (safety 3) (speed 0)).
<anniepoo>
I want to eval (foo 1 2) with debugger (that is, single step)
<pillton>
In SBCL/SLIME you can then use the restarts to step through the code.
<anniepoo>
ok, thanks
mejja has joined #lisp
<pillton>
I don't think this functionality is as good as it is in other development environments. Having said that, what is the right thing to do with macros?
<anniepoo>
turns out
<anniepoo>
(step (foo 1 2)) works
<pillton>
Well there you go. I didn't know about step.
<anniepoo>
8cD
<pillton>
I debug with unit tests and print/format.
<anniepoo>
I'm a noob, single stepping can be education as well as debug
<aeth>
Debugging with FORMAT doesn't seem like the end of the world. Shouldn't be too hard to refactor into logging if you leave it in and target any stream.
<pillton>
I don't leave it in.
Essadon has quit [Quit: Qutting]
it3ration has joined #lisp
eddof13 has quit [Quit: eddof13]
it3ration has quit [Ping timeout: 268 seconds]
<dariken>
how to make executable binary in SBCL that doesnt take the whole Lisp image with it? something like tree shaking that only takes the necessary parts.
<anniepoo>
hey dariken
<anniepoo>
I'm writing such a tool now
gigetoo has quit [Ping timeout: 268 seconds]
<anniepoo>
sadly not ready yet
<pillton>
dariken: That isn't possible. You can pass :compression t to sb-ext:save-lisp-and-die.
smokeink has quit [Remote host closed the connection]
<fiddlerwoaroof>
dariken: in the general case, I think that's equivalent to the halting problem
smokeink has joined #lisp
<fiddlerwoaroof>
because of things like (apply (read) 1)
gigetoo has joined #lisp
smokeink has quit [Remote host closed the connection]
<anniepoo>
(fwiw, yes, the one I'm presumably gonna write has to have some limitations - it's known to be impossible in the general case, like apply)
wanz has joined #lisp
smokeink has joined #lisp
nanoz has quit [Ping timeout: 245 seconds]
<fiddlerwoaroof>
anniepoo: if you're having issues with macros, the macrostep expander is really useful
be_knoll has joined #lisp
<anniepoo>
no, I was having a more fundamental problem
<fiddlerwoaroof>
C-c M-e starts it
<fiddlerwoaroof>
Yeah, this is more informational than anything else
no-defun-allowed has quit [Ping timeout: 250 seconds]
Jachy has quit [Ping timeout: 252 seconds]
LdBeth has quit [Ping timeout: 252 seconds]
siraben has quit [Ping timeout: 250 seconds]
Gnuxie[m] has quit [Ping timeout: 252 seconds]
djeis[m] has quit [Ping timeout: 264 seconds]
xylef has quit [Ping timeout: 276 seconds]
equwal has quit [Read error: Connection reset by peer]
Roy_Fokker has quit [Read error: Connection reset by peer]
mkolenda has quit [Read error: Connection reset by peer]
SaganMan has joined #lisp
anewuser has joined #lisp
emerson has quit [Remote host closed the connection]
SaganMan has quit [Client Quit]
mkolenda has joined #lisp
ryan_vw has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
Arcaelyx has joined #lisp
mkolenda has quit [Read error: Connection timed out]
esrse has joined #lisp
mkolenda has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
elderK has joined #lisp
<oni-on-ion>
pillton: not possible? anniepoo: working on it?? o_O
smokeink has quit [Ping timeout: 240 seconds]
SaganMan has joined #lisp
dorketch has quit [Quit: WeeChat 2.3]
Salvakiya has quit [Quit: Leaving]
xylef has joined #lisp
brettgilio has joined #lisp
arescorpio has quit [Quit: Leaving.]
Manny8888 has joined #lisp
be_knoll has quit [Ping timeout: 250 seconds]
Kundry_Wag has joined #lisp
ldb has joined #lisp
LdBeth has joined #lisp
<LdBeth>
That’s true, but I believe cl-ppcre won’t need debugger or profiler to run :&
<ldb>
Ok, I’m on
ldb has quit [Client Quit]
no-defun-allowed has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
robotoad has joined #lisp
<LeoLiang>
Hello
it3ration has joined #lisp
it3ration has quit [Remote host closed the connection]
it3ration has joined #lisp
<SaganMan>
Morning beach
<SaganMan>
Morning #lisp
<LdBeth>
Morning
<no-defun-allowed>
hi everyone
<SaganMan>
why no-defun-allowed?
<SaganMan>
isn't defun good?
<oni-on-ion>
great; just not allowed
<no-defun-allowed>
you must use (setf (fdefinition ...) (lambda ...))
emaczen has joined #lisp
<aeth>
What if I use define-function instead?
<fiddlerwoaroof>
stylewarning: is there any way to get the value of a just in cl?
jack_rabbit has quit [Ping timeout: 260 seconds]
<stylewarning>
fiddlerwoaroof: you mean unpack it?
<fiddlerwoaroof>
I guess so, e.g. (Just 3) => 3
<stylewarning>
fiddlerwoaroof: no way except to access the slot directly. That'll change in due time of course.
<stylewarning>
(slot-value x 'coalton-impl::value)
<fiddlerwoaroof>
And that's just a vector
<stylewarning>
yes
<fiddlerwoaroof>
with one item per type parameter?
<stylewarning>
whose length is equal to the arity of the constructor
<stylewarning>
fiddlerwoaroof: correct
it3ration has quit [Ping timeout: 252 seconds]
<stylewarning>
(Supposing that I don't replace it with structs, I'll probably make each one its own slot. But it's a detail I'm not so concerned with at the moment.)
<stylewarning>
(in Coalton, of course, the way to extract values will be through pattern matching, which also isn't implemented)
<fiddlerwoaroof>
:)
<fiddlerwoaroof>
Yeah, I just wanted to figure out how to get a better repl experience :)
<stylewarning>
fiddlerwoaroof: i'm happy to take a PR to just add that, even if it changes
<fiddlerwoaroof>
I suppose this can be done generically, right?
<jcowan>
I've actually been wearing my ISLisp implementor's hat today, thinking about how to implement ISLisp in CL. I'm realizing that it's going to be *very* expensive to use only portable CL rather than being able to depend on SBCL
<fiddlerwoaroof>
jcowan: I think there is an implementation already, if you need inspiration
<jcowan>
For example, (+ 'x) only should raise an error per CLHS, but SBCL guarantees to return an error. So either I wrap + with a safe version that always raises an error (and not by a type declaration either, but by actual code), or I just say "Use SBCL".
<jcowan>
Kent Pitman has an implementation, but he can't/won't open source it. There is OpenLisp, which is not open, and a bunch of broken implementations.
<fiddlerwoaroof>
Anyways, I have a suspicion that that type of thing always _will_ raise an error in implementations people user
<fiddlerwoaroof>
s/user/use/
Kundry_Wag has joined #lisp
<anamorphic>
When would one pick an ISLisp over a Common Lisp?
<jcowan>
When you are willing to trade away dynamic behavior (other than dynamic typing).
<fiddlerwoaroof>
Why wouldn't you :)
<jcowan>
ISLisp is extremely static; it's designed for a whole-program compilation model.
<jcowan>
Still, I'm glad Pascal has written one
<fiddlerwoaroof>
I only know about it because it's been adapted to work with a racket-module like system
<fiddlerwoaroof>
Now, if only there were an open source impl of lelisp
<stylewarning>
fiddlerwoaroof: also I welcome issues being filed, even glaringly obvious ones
<fiddlerwoaroof>
ok
no-defun-allowed has quit [Ping timeout: 264 seconds]
LdBeth has quit [Ping timeout: 252 seconds]
Manny8888 has quit [Ping timeout: 264 seconds]
xylef has quit [Ping timeout: 276 seconds]
<pfdietz>
ML was originally part of LCF, wasn't it?
capadoodle has joined #lisp
mkolenda has quit [Read error: Connection reset by peer]
mkolenda has joined #lisp
ryan_vw has joined #lisp
<fiddlerwoaroof>
stylewarning: I've sent a minor PR for print-method
<fiddlerwoaroof>
ugh, print-object
<fiddlerwoaroof>
Anyways, I think your implementation of Hindley-Milner might be my best chance of my understanding how the algorithm works: it looks a lot cleaner than most of the other places I've looked
<fiddlerwoaroof>
This might be because I'm really bad at reading ML-style languages or my eyes glaze over when people write page after page of type judgments
jack_rabbit has joined #lisp
nanoz has joined #lisp
* fiddlerwoaroof
wonders if a non-toy lisp has ever been implemented in smalltalk
mkolenda has quit [Read error: Connection reset by peer]
<fiddlerwoaroof>
I'm kinda interested to what degree a lisp would benefit from something like the smalltalk "IDE"
<oni-on-ion>
yeap =) opengenera was closest; lisp experiments were precursor to smalltalk environment afaik. current attempts are mezzano and mcclim
<stylewarning>
fiddlerwoaroof: one small item
<stylewarning>
(on the PR)
jack_rabbit has quit [Ping timeout: 264 seconds]
anamorphic has quit [Ping timeout: 245 seconds]
<jcowan>
Interlisp (of which Genera is the only surviving implementation) and Smalltalk came out of the same hacker culture, and they shared a great deal, especially the image-based rather than file-based representation.
<fiddlerwoaroof>
stylewarning: cool, accepted them
<fiddlerwoaroof>
jcowan: yeah, one of my many overly ambitious projects is to implement a fully-image based modern CL system
<fiddlerwoaroof>
I've been thinking of using sqlite's appendvfs to append a relational database to an image, and stuff all the source in there with arbitrary metadaya
<fiddlerwoaroof>
And then define a suite of functions that can generate temporary buffers from the database that contain a projection of your source-code
<jcowan>
There are bits in the Squeak image that were set by hand before 1980 and have no representation in the source file.
<fiddlerwoaroof>
i.e. something like (buffer-with-methods generic-function &rest specializers) that would give you a temp file with all the relevant methods
<fiddlerwoaroof>
jcowan: I thought that at some point they went back and reimplemented the vm from scratch so that that was no longer the case?
SaganMan has quit [Quit: WeeChat 1.6]
<jcowan>
The VM yes, the image no.
<fiddlerwoaroof>
Ah, makes sense
<fiddlerwoaroof>
That's sort of cool
<jcowan>
The image was reformatted for 32 and then 64 bits, but that's all
<oni-on-ion>
emacs
<fiddlerwoaroof>
emacs is still file-oriented
<jcowan>
Xerox sent out the image and a bunch of docs to various outside organizations and asked them to implement VMs according to their own notions, and the result was a lot of Smalltalks and the book _Bits of History, Words of Advice_
<fiddlerwoaroof>
And, it works by leaning really heavily on the type system to generate a bunch of the boilerplate necessary to serve an api
capadoodle has joined #lisp
<fiddlerwoaroof>
So, my thought is that if you declare assumed-good types for a bunch of functions and use those in a server spec and if you had a type-only checker, you could get the code generation "a la carte"
<fiddlerwoaroof>
And, optionally, contract generation to check the assumptions
cylb has joined #lisp
emaczen has quit [Remote host closed the connection]
emaczen has joined #lisp
cylb has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
stylewarning: one thing that occurs to me is that your coalton-toplevel macro return an "environment constructor"
<fiddlerwoaroof>
that is, a function that, given some object that represents an environment, updates it to have the definitions contained inside the macro form
<fiddlerwoaroof>
That might allow for less complicated macro stuff.
<stylewarning>
that's true, and i'd be happy for the macro stuff to be less complicated
<fiddlerwoaroof>
I thought the way j-bob (the theorem prover from The Little Prover) handles this was quite eleagant
<fiddlerwoaroof>
Although, the downside would be that host/coalton interop becomes a little more complicated.
sword` has quit [Remote host closed the connection]
<beach>
Good morning everyone!
aindilis has quit [Ping timeout: 244 seconds]
shka_ has quit [Ping timeout: 240 seconds]
aindilis has joined #lisp
scymtym has quit [Ping timeout: 268 seconds]
robotoad has quit [Read error: Connection reset by peer]
shrdlu68 has joined #lisp
robotoad has joined #lisp
DGASAU has quit [Remote host closed the connection]
DGASAU has joined #lisp
Kaisyu has joined #lisp
<elderK>
Good morning, Beach!
wanz has quit [Remote host closed the connection]
rozenglass has quit [Remote host closed the connection]
robotoad has quit [Quit: robotoad]
<beach>
So it looks like it3ration was here mostly to tell us how nice Clojure is an how ugly Common Lisp is, and not so much to get information about Common Lisp.
<elderK>
I missed that.
<elderK>
I don't get the bad rap people give CL. I was reading some blog posts today, by Fare, who linked to other such posts, about people banging on CL.
<beach>
Somehow, I can't see myself going to #clojure and ranting about how I like mutable data structures, lisp-2, etc.
<elderK>
I mean, I've never found anything in CL all that horrible. Maybe that's just because I'm used to C and C++ but like, nothing stands out as being outright @!#$ing crap.
<elderK>
As for namespaces, I like that functions live in their own namespace. It makes some things much clearer. Like, how many times have you seen Scheme code with "lis" as a parameter?
<elderK>
Or "lst"
<beach>
Well, you can like it or not. That's not my point. My point is that it is kind of weird to show up in a forum dedicated to language X and spend most of the time ranting about how great language Y is and how bad language X is.
<elderK>
Yeah, somehow various contractions of mutations of "list" are better...
<elderK>
Yeah, it is.
<elderK>
It's rude at best.
<beach>
"I do prefer the way Lisp-1's look"
<beach>
"I hate seeing (funcall stuff ..)"
<beach>
"The names of things seem super antiquated compared to Clojure (aka, remove-if-not instead of filter"
<no-defun-allowed>
to be honest, neither is better and both have places where they look awkward
<elderK>
Aye.
<elderK>
That's the truth.
<no-defun-allowed>
which is why i propose a new system: lisp1.5 (not to be confused with the 1960's implementation)
<no-defun-allowed>
interpret/compile/whatever the syntax both ways and use which one handles the most test cases correctly
<beach>
Again, that's not my point. My point is that it's strange to come to #lisp and rant about how bad it is and how good Clojure is.
<no-defun-allowed>
that's also silly
<elderK>
It's like, sure, I prefer a general "define" like in Scheme vs. defun, etc, etc. But so what? It's not like it's a major issue. You use defun a few times, and you learn and no problem.
<elderK>
Ae.
<beach>
I don't get that kind of behavior.
<shrdlu68>
Perhaps it's time "Comparative PL design" became a thing? Clearly people enjoy comparing languages.
<beach>
"Hey, you people, I am here to tell you that you have been wrong the entire time"
<elderK>
That's going to go over well :P
<shrdlu68>
Well, if onr of your biggest gripes with CL is "remove-if-not", clearly it got the important things right.
<beach>
Especially since "filter" is ambiguous.
<no-defun-allowed>
r-i(-n) is clearer than filter
<beach>
Does it remove things or keep things.
<beach>
?
<beach>
no-defun-allowed: Exactly!
<no-defun-allowed>
filter would give you both parts as multiple values
nanoz has joined #lisp
Colleen has quit [Remote host closed the connection]
Colleen has joined #lisp
<elderK>
I like the name remove-if-not. It's clear.
<no-defun-allowed>
(defun filter (pred list) (loop with in-pan = nil with in-bowl = nil for item in list do (if (funcall pred item) (push item in-bowl) (push item in-pan)) finally (return (values (nreverse in-bowl) (nreverse in-pan)))))
<elderK>
Someone who isn't a functional person can se eit, and understand what it is doing. But if you see filter? Like beach said: Is it removing? Is it keeping things? What?
<no-defun-allowed>
although the model should probably be the other way around since you're looking down onto your bench, the pan's contents are first
<shrdlu68>
Can't say I've never been tempted to go on a vitriolic diatribe against some languages, just never done it.
<no-defun-allowed>
doesn't work very well, even if you're right
nanoz has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
(eg: new rust macros give you a stream of tokens instead of an AST. the response i got from "what the hell is this nonsense, the compiler has a full parser!" was "just include a parser crate it's less stuff they have to put in the core")
<jackdaniel>
people coming here and "proving" that their language of choice is better is a defensive stance
<jackdaniel>
if I had to guess such people hear from somewhere, that CL is better because of *something* and feel compelled to defend themself
<shrdlu68>
There you go - an opportunity to write a damaging polemic, like Chomsky's review of Skinner's Verbal Behavior.
<jackdaniel>
but it is rude indeed to barge in to say: your choice sucks (because I truly believe despite what I've heard that my language is better)
shka_ has joined #lisp
<shka_>
good morning
<elderK>
Mornin' shka_
<shrdlu68>
"perhaps the most devastating review ever written"
<shka_>
shrdlu68: sound fun, source?
<shrdlu68>
But I doubt one can write something like that in this field and not be accused of malice.
<shrdlu68>
Hypothesis: no critique of a programming language can ever be taken seriously as a scholarly work.
<jackdaniel>
word I was looking for was "insecure"
<jackdaniel>
s/because I truly …/because I feel insecure/
<beach>
Yes, that sounds right.
nirved has joined #lisp
<shka_>
shrdlu68: i agree with that statement
stevelemuel has quit [Quit: Textual IRC Client]
<shka_>
but again, many things shouldn't be taken seriously as a scholarly work
<shrdlu68>
Perhaps because there just isn't any established methodology of going about it.
<shrdlu68>
Or because it is not considered to be within the scope of "computing science".
<shka_>
maybe, but i doubt we will ever have such methodology
<shka_>
precisely because it is between computer science and psychology
<shka_>
and humans are freaking complicated
sword has joined #lisp
<shrdlu68>
Hence we end up with an industry where the only books ever written are tutorials.
* shrdlu68
gets back to work
<beach>
Good idea.
Zaab1t has joined #lisp
<shka_>
shrdlu68: well, this is how it is, but I even named my blog "for more humane computing"
<shka_>
so you can guess my opinion
heisig has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
themsay has quit [Ping timeout: 244 seconds]
orivej has joined #lisp
rozenglass has joined #lisp
akovalenko has quit [Ping timeout: 244 seconds]
varjag has joined #lisp
jochens has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
shrdlu68 has quit [Ping timeout: 244 seconds]
akovalenko has joined #lisp
shrdlu68 has joined #lisp
myrkraverk has joined #lisp
jcowan has quit [Quit: Connection closed for inactivity]
marvin2 has quit [Ping timeout: 245 seconds]
_whitelogger has joined #lisp
thijso has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
xkapastel has joined #lisp
<zigpaw>
Speaking about language choice, yesterday I was looking at a live stream of someone who wrote a GUI application using Power Shell script, and kept data in CSV files. One of my first thoughts was - how much pain can we cause to ourselves. On the other hand he wasn't working as software developer so as far as I am concerned I was quite happy he was d
<zigpaw>
oing it and sharing his learning experience.
<jackdaniel>
I've seen far worse solutions for data storage than storing it in csv (and some of them required quite a sophisticated knowledge)
<jackdaniel>
ORM is one from the top of my head :)
<jackdaniel>
xml is another funny choice for data storage
hhdave has joined #lisp
<zigpaw>
and quite popular one.
<shka_>
xml is not all that bad
<jackdaniel>
ha ha
<zigpaw>
depends on what you put in there ;)
<shka_>
heh
<shka_>
also, depends on comparasion with other formats
<shka_>
like json
<jackdaniel>
so I think that csv is a sane choice for really small projects, then comes sqlite and then database which is more suited for bigger quantities of data
<zigpaw>
(just to add context, he had one file of ~2GB of CSV data)
<jackdaniel>
oh, then csv was probably not a good choice indeed
<zigpaw>
yeah, he probably chose it because the source data was in CSV.
<shka_>
database would be a better choice i think, but if it solved his issue, good for him
<heisig>
My preferred choice of storage is objects in Lisp images. The reasoning is that life is too short to spend it with data serialization and deserialization.
<heisig>
Of course, sometimes you have to bite the bullet...
<zigpaw>
shka_: exactly my thoughts :-)
Zaab1t has quit [Quit: bye bye friends]
<jackdaniel>
heisig: arguably it is not a storage then but a port of the program
<jackdaniel>
part*
nsrahmad has joined #lisp
* beach
totally agrees with heisig.
mope has joined #lisp
astalla has joined #lisp
nsrahmad has quit [Read error: Connection reset by peer]
m00natic has joined #lisp
igemnace has quit [Quit: WeeChat 2.3]
esrse has quit [Ping timeout: 264 seconds]
Gnuxie[m] has joined #lisp
themsay has joined #lisp
moei has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
neirac has joined #lisp
frgo_ has quit [Remote host closed the connection]
anewuser has quit [Ping timeout: 240 seconds]
frgo has joined #lisp
frgo has quit [Ping timeout: 252 seconds]
elderK has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
themsay has quit [Ping timeout: 252 seconds]
frgo has joined #lisp
frgo has quit [Ping timeout: 276 seconds]
ggole has joined #lisp
frgo has joined #lisp
<dim>
guys, databases are NOT solving a storage problem
<dim>
use a database when you have concurrency issues
frgo has quit [Ping timeout: 252 seconds]
<dim>
having 2GB of data in main memory is easy nowadays, even on a laptop, so that's not any problem for an application to solve, what's complex is accessing the single/shared data set in read and write operations from concurrent activities, and that's when transactions and ACID and whatnot get to be meaningful
frgo has joined #lisp
<dim>
as soon as you support more than one client doing even an INSERT concurrently, then you need to think in terms of transactions and serialisation, and then database, even if that's for a 2kb of data
jcowan has joined #lisp
nirved is now known as Guest96254
nirved has joined #lisp
xrash has quit [Ping timeout: 268 seconds]
Guest96254 has quit [Ping timeout: 252 seconds]
Bike has joined #lisp
orivej has quit [Remote host closed the connection]
orivej has joined #lisp
<fe[nl]ix>
dim: you can even have 2TB in main memory nowadays :)
anewuser has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
drewes has joined #lisp
<pfdietz>
If you want to treat lisp programs as objects, an image based system becomes more convenient. Reader hacking in Common Lisp, like the preprocessor in C, makes it hard to represent the program.
<pfdietz>
I suppose ordinary macros do too to some extent, although not at the level of character-based syntax.
<pfdietz>
One thing I had to get used to moving from Interlisp to Common Lisp was comments were no longer sexprs.
nicksmaddog has joined #lisp
cylb has joined #lisp
omilu has joined #lisp
charh has joined #lisp
igemnace has joined #lisp
neirac has quit [Ping timeout: 245 seconds]
Essadon has joined #lisp
milanj has joined #lisp
<jcowan>
Many people think that was a mistake.
<jcowan>
I didn't know you were an ex-Interlisper too. Any others around here?
nanoz has joined #lisp
nanoz has quit [Ping timeout: 244 seconds]
dale has joined #lisp
Guest70792 has quit [Remote host closed the connection]
Guest70792 has joined #lisp
<pfdietz>
I used D-machines when I was at Schlumberger.
<pfdietz>
The interesting (to me) question: what are the things that are done to programs? Compiling and running them, for sure, but what else? These would affect language design.
<jackdaniel>
packaging for different platforms
FreeBirdLjj has joined #lisp
<jackdaniel>
versioning them, composing with other programs
<jackdaniel>
testing of course
<jackdaniel>
(hm, I hope it wasn't rethorical question, that would be silly of me to answer it)
<pfdietz>
Not rhetorical at all.
<pfdietz>
I think listing use cases for programs as things to be manipulated would be very interesting.
<jackdaniel>
in less narrow sense: sharing runtime (we could look for instance at irc as a single program shared between peers)
sjl_ has joined #lisp
<jackdaniel>
managing extensions (different builds / run flags)
Zaab1t has joined #lisp
<pfdietz>
Off the top of my head: verification and other kinds of static analysis, diffing, refactoring, test generation, documentation extraction, generation of human-readable explanations of program behaviors, instrumentation (and other aspect-like changes).
<jackdaniel>
keeping documentation as a part of the program would be nice too
<jackdaniel>
maintaining development-related information (i.e program could host its own source code, issues, wiki, documentaiton), so if it hosts its own code – merging two program forks
<jackdaniel>
rebuilding in-place from the self-hosted sources
<jackdaniel>
my wishlist goes somewhere abstract, I'll keep quiet for a while :p
jochens has quit [Ping timeout: 246 seconds]
rumbler31 has quit [Remote host closed the connection]
<pfdietz>
Anyway, the program manipulation API affects language design, and I think it would make sense to make it more explicitly defined.
<Inline>
i'm ok, doing ok and getting better every day
frgo has quit [Ping timeout: 260 seconds]
<ogamita>
Inline: you should be immortal then.
rippa has joined #lisp
<zigpaw>
jackdaniel: have you looked at Elixir doc tests? I think that is also quite a neat idea that could add to your great list above.
fikka has quit [Ping timeout: 272 seconds]
<jackdaniel>
I'm familiar with the concept nad I find it really messy to mix: function body, documentation and unit tests in the same block with a weird syntax
marvin2 has joined #lisp
<jackdaniel>
having it all accessible from one place (with help of the editor) makes more sense, but they shouldn't be lumped together in text
jochens has joined #lisp
<splittist>
jackdaniel: in the code-editing view of the text
ogamita has quit [Quit: I'll be back.]
jochens_ has quit [Ping timeout: 268 seconds]
<dim>
is anyone here deploying CL code to Heroku or some equivalent services?
matzy_ has joined #lisp
jochens_ has joined #lisp
jochens has quit [Ping timeout: 246 seconds]
frgo has joined #lisp
eddof13 has joined #lisp
eddof13 has quit [Client Quit]
eddof13 has joined #lisp
shka_ has quit [Quit: WeeChat 1.9.1]
matzy_ has quit [Ping timeout: 256 seconds]
frgo has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
hvxgr has quit [Ping timeout: 252 seconds]
hvxgr has joined #lisp
eddof13 has quit [Quit: eddof13]
eddof13 has joined #lisp
emerson has joined #lisp
hvxgr has quit [Ping timeout: 240 seconds]
hvxgr has joined #lisp
matzy_ has joined #lisp
rumbler31 has joined #lisp
scymtym has joined #lisp
rumbler31 has quit [Ping timeout: 268 seconds]
jochens has joined #lisp
heisig has quit [Quit: Leaving]
jochens_ has quit [Ping timeout: 268 seconds]
drot has joined #lisp
frgo has joined #lisp
edgar-rft has quit [Remote host closed the connection]
robotoad has joined #lisp
nonlinear has quit [Ping timeout: 252 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
flazh has quit [Read error: Connection reset by peer]
flazh has joined #lisp
shka_ has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<shka_>
good evening\
<beach>
Hello shka_.
astalla has quit [Ping timeout: 252 seconds]
rozenglass has quit [Remote host closed the connection]
kajo has joined #lisp
nly has joined #lisp
anewuser has quit [Ping timeout: 252 seconds]
nicksmaddog has quit [Read error: Connection reset by peer]
flazh has quit [Quit: flazh]
flazh has joined #lisp
anewuser has joined #lisp
ggole has quit [Quit: ggole]
flazh has quit [Read error: Connection reset by peer]
flazh has joined #lisp
anewuser has quit [Quit: anewuser]
jochens has quit [Read error: Connection reset by peer]
jochens_ has joined #lisp
<Xach>
dim: i think i've seen that
<Xach>
dim: it is pretty old but there is a thing on github under joaotavora
orivej has quit [Ping timeout: 272 seconds]
<dim>
thanx Xach... I have this project in mind that seems quite simple to begin with, and I'm wondering if Heroku and then Python would make it so much easier for me, because the goal is not the write the code but to host a user available service…
<dim>
so a good Common Lisp web hosting facility would be great maybe
<Xach>
ah
<Xach>
because I am Very Old i have used my own bare-metal servers for a very long time
<Xach>
i don't have any recommendations as a result, sorry
<dim>
or, if I don't find an existing platform that implements my ideas, I could also subcontract this part, but I'd rather than something that is known to be worry free and scaling easily
<dim>
I want to have to deal with as few moving parts as possible myself, that's not where the added value is in that project
<Xach>
Sensible
LiamH has joined #lisp
jochens_ has quit [Remote host closed the connection]
jochens has joined #lisp
SaganMan has joined #lisp
hhdave has quit [Ping timeout: 268 seconds]
mope has quit [Quit: Lost terminal]
Kaisyu has quit [Quit: Connection closed for inactivity]
jochens has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
<fiddlerwoaroof>
dim: my impression of Heroku is that it gets really expensive once you move past the "hobby project" stage
<fiddlerwoaroof>
Anyways, if hosting options are flexible, deploying docker containers to some managed kubernetes provider or to AWS ECS/Fargate might be good option
<fiddlerwoaroof>
Also, if the language choice is flexible, there's Clojure things like Datomic Cloud.
shrdlu68 has quit [Ping timeout: 240 seconds]
brettgilio has quit [Ping timeout: 240 seconds]
m00natic has quit [Remote host closed the connection]
makomo has joined #lisp
<makomo>
hello
<dim>
fiddlerwoaroof: yeah agreed Heroku can get quite expensive when you get lots of traffic, I'm not sure I will get that though
<dim>
fiddlerwoaroof: Clojure looks like a decent lisp from what I've seen before, but this project isn't a good opportunity to discover a new language from scratch
Guest70792 has quit [Ping timeout: 252 seconds]
rozenglass has joined #lisp
sauvin has quit [Remote host closed the connection]
charh has quit [Ping timeout: 245 seconds]
Zaab1t has quit [Quit: bye bye friends]
moei has quit [Read error: Connection reset by peer]
milanj has quit [Quit: This computer has gone to sleep]
lumm has joined #lisp
<dim>
wow I need to look into that, for building static image of pgloader
<dim>
fiddlerwoaroof: would you be interested in contributing a build process for static pgloader images?
lumm has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
Maybe, if I can find some time. The complicated thing is that, as far as I know, it only works on sbcl and you need to build sbcl specially
<fiddlerwoaroof>
(with the --linkable-runtime flag, at the very least)
<fiddlerwoaroof>
Which CI does pgloader use?
tumdum has quit [Quit: Leaving]
<fiddlerwoaroof>
nevermind
<fiddlerwoaroof>
dim: I'll look into adding it to the code.
orivej has joined #lisp
LdBeth has joined #lisp
<LdBeth>
Good morning
lumm has joined #lisp
paul0 has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
paul0 has joined #lisp
it3ration has joined #lisp
cylb has quit [Ping timeout: 244 seconds]
robdog has joined #lisp
it3ration has quit [Ping timeout: 246 seconds]
eddof13 has quit [Quit: eddof13]
<dim>
fiddlerwoaroof: awesome, thanks for willing to have a look!
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
elderK has joined #lisp
DGASAU has quit [Ping timeout: 252 seconds]
anniepoo has quit [Ping timeout: 245 seconds]
<elderK>
Morning all.
sjl_ has quit [Quit: WeeChat 2.3-dev]
sjl_ has joined #lisp
benjamin-l has joined #lisp
eddof13 has joined #lisp
DGASAU has joined #lisp
shka_ has quit [Ping timeout: 244 seconds]
cylb has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
xrash has joined #lisp
it3ration has joined #lisp
edgar-rft has joined #lisp
<elderK>
Guys, is the usual way to store an element in an enumeration, to store a symbol?
<elderK>
I've defined a new type, with deftype, that specifies which symbols are valid for that "type."
<elderK>
(I read that like, enumeration values C-style - you know, symbolic names for integers, aren't the way to do things in CL?)
VKraft has joined #lisp
<sjl_>
That's one way I've used before, yeah
<elderK>
What are the alternatives? :)
<elderK>
I was hoping that if I created an array of my type, the system would prevent me from say, setting an element of that array to some symbol outside of those specified by deftype. I've since learned about element type upgrading. So, the array accepts things of T.
<sjl_>
Right, you'd need to (check-type foo your-enum) to ensure they actually get checked.
<sjl_>
I've used integers before for things like emulator opcodes, to be able to easily look up things about them (e.g. their functions) in an array later.
<elderK>
Right, so you'd have functions that are used to mess with the array, and have the appropriate check-type in them, correct?
<sjl_>
Yeah
<elderK>
Thanks :)
<sjl_>
Depending on your implementation you may get more or less help with the type checking. SBCL on (safety 3) is pretty helpful
<sjl_>
e.g. in SBCL if I do (deftype http-method () '(member get put post delete ...)) and then later (declaim (ftype (function (http-method string) t) query)) (defun query (method url) ...)
<sjl_>
and then later do (query nil "http://foo.com") later, SBCL will warn me that nil isn't an http-method
<sjl_>
But that's implementation (and optimization) specific
<elderK>
Right, so for now, I should just use check-type.
<sjl_>
If you want to be sure the types are verified, use check-type
<elderK>
Just starting out you see. Finals are coming to an end, and I thought as a "learning project", I'd implement a (tough) assignment I did earlier in the year, but in CL.
<sjl_>
or etypecase or ctypecase if those are more appropriate for what you're trying to do
<sjl_>
I end up using [ec]typecase surprisingly often
<elderK>
Post it here for critique, hopefully improve and learn :)
<sjl_>
Yeah. If you want code review you can post it here and people are generally happy to critique things to varying degrees of nitpickiness
<elderK>
I'm happy with nitpicking and all, provided it's constructive :)
<elderK>
I imagine what I write at first will be pretty terrible. I hope to learn the better ways :)
<elderK>
It's like, there's a lot of "shortcuts' I'm used to using in C. None of those will work here.
<elderK>
So it's going to be interesting to learn how to do things nicely the CL way :)
<elderK>
This seems like a good little project. It's a solver for a cellular automata kind of thing. It's simple in that it doesn't need a lot of libraries and stuff. But not trivial. Seemed like a good fit :)
VKraft has quit [Quit: Leaving]
<sjl_>
Yeah, something nontrivial but not super involved is a good starting place. Especially something you've done before, so you're not trying to understand both the problem itself and a new language at the same time.
anamorphic has joined #lisp
cpt_nemo has joined #lisp
lumm_ has joined #lisp
<sjl_>
One thing to keep in mind about shortcuts, is that a lot of CL people (e.g. me) care a lot about brevity of *ideas*, and don't care much about brevity of *characters*.
lumm has quit [Ping timeout: 252 seconds]
lumm_ is now known as lumm
<sjl_>
e.g. to concatenate two bytes, a C programmer might do (a<<8)|b whenever they want to do that.
<sjl_>
someone like me would (declaim (inline concatenate-bytes)) (defun concatenate-bytes (high-order low-order) (logior (ash high-order 8) low-order))
<sjl_>
and then (concatenate-bytes a b)
<sjl_>
It's more characters to type "(concatenate-bytes ... ...)" than "...<<8|...", but instead of saying two things every time (shift, or) I'm saying exactly what I mean