<pjb>
pierpa: notice that with emacs, you can easily bind any unicode character to an easy key or key-chord.
arescorpio has joined #lisp
<pjb>
So the convenience can be as high as you want.
nowhere_man has quit [Ping timeout: 256 seconds]
damke_ has quit [Ping timeout: 264 seconds]
<pjb>
pierpa: of course, with emacs, you can also have the convenience the other way: display a long-name as a single unicode character (with the compose operator, see eg. https://www.emacswiki.org/emacs/PrettyLambda
<Josh_2>
How do I use sb-concurrency?
<pierpa>
pjb: that's REALLY not easily accessible.
<Josh_2>
It's listed in the SBCL 1.4.6 manual but it isn't being recognized by the SBCL I'm using atm
<Josh_2>
Wait I got it
milanj__ has joined #lisp
<Josh_2>
fyi gotta use (require :sb-concurrency) :D
wxie has quit [Ping timeout: 240 seconds]
<antoszka>
pierpa: guess I can see one piece missing, there are make-inet{,6}-address functions for parsing the string, but there are no equivalent print functions, maybe that could use some work.
<antoszka>
And having both pairs I could create a very thin reader macro on top of those.
<pierpa>
antoszka: wrong name :)
wxie has joined #lisp
<antoszka>
Well, you and Bike :)
<pierpa>
:)
<antoszka>
Anyway, have to get on the plane now, talk to you later guys (hopefully :))
<pierpa>
fly well
<antoszka>
ty
JohanP has quit [Read error: Connection reset by peer]
wxie has quit [Ping timeout: 264 seconds]
MasouDa has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 240 seconds]
nowhere_man has joined #lisp
fikka has joined #lisp
damke has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 260 seconds]
damke has joined #lisp
asarch has joined #lisp
Karl_Dscc has joined #lisp
zachk has quit [Quit: night]
fikka has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
ealfonso has joined #lisp
<ealfonso>
I have N long-running threads performing some work. occasionally I'd like to peek into the current state of the work from an event-driven thread. I've thought about having each thread write to a global hash table but is there a better way?
pmetzger has left #lisp [#lisp]
wxie has joined #lisp
Baggers has quit [Remote host closed the connection]
<ealfonso>
the event requires the long-running thread to stop, compute an serializable state object, then continue altering the state
fikka has joined #lisp
d4ryus2 has joined #lisp
d4ryus1 has quit [Ping timeout: 240 seconds]
yoel has joined #lisp
doanyway has joined #lisp
Kundry_Wag has joined #lisp
EvW has quit [Ping timeout: 255 seconds]
yoel has quit [Ping timeout: 268 seconds]
comborico1611 has quit [Quit: Konversation terminated!]
dtornabene has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 264 seconds]
dtornabene has quit [Read error: Connection reset by peer]
dtornabene has joined #lisp
wxie has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
fikka has joined #lisp
wxie has quit [Remote host closed the connection]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
DataLinkDroid has quit [Quit: Alla prossima volta]
megalography has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 248 seconds]
megalography has joined #lisp
fikka has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
wxie has joined #lisp
kushal has quit [Remote host closed the connection]
v0|d has joined #lisp
megalography has quit [Ping timeout: 264 seconds]
Kundry_W_ has joined #lisp
Pixel_Outlaw has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Kundry_W_ has quit [Ping timeout: 248 seconds]
megalography has joined #lisp
fikka has joined #lisp
kushal has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 260 seconds]
comborico1611 has joined #lisp
fikka has joined #lisp
jibanes has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 248 seconds]
jibanes has joined #lisp
arescorpio has quit [Quit: Leaving.]
fikka has joined #lisp
surya has joined #lisp
doanyway has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 248 seconds]
Josh_2 has quit [Remote host closed the connection]
doanyway has joined #lisp
ealfonso has quit [Remote host closed the connection]
ealfonso has joined #lisp
<beach>
Good morning everyone!
wxie has joined #lisp
fikka has joined #lisp
comborico1611 has quit [Ping timeout: 264 seconds]
doanyway has quit []
SlowJimmy has quit [Ping timeout: 255 seconds]
Lord_Nightmare has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Remote host closed the connection]
fikka has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
fikka has joined #lisp
pierpa has quit [Quit: Page closed]
Kundry_Wag has quit [Ping timeout: 240 seconds]
asarch has quit [Remote host closed the connection]
asarch has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
edgar-rft has quit [Quit: edgar-rft]
phax has joined #lisp
detectiveaoi has joined #lisp
SuperJen has joined #lisp
brendyn has joined #lisp
fikka has joined #lisp
JenElizabeth has quit [Ping timeout: 240 seconds]
zaquest has quit [Ping timeout: 240 seconds]
zaquest has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
pierpal has quit [Ping timeout: 276 seconds]
Kevslinger has quit [Quit: Connection closed for inactivity]
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
quazimodo has quit [Ping timeout: 264 seconds]
<phoe>
Morning
<beach>
Hello phoe.
yoel has joined #lisp
fikka has joined #lisp
yoel has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
<theemacsshibe[m]>
i wrote a scheme(ish thing) for c64
surya has quit [Read error: Connection reset by peer]
damke has quit [Ping timeout: 264 seconds]
<theemacsshibe[m]>
(well i didn't write very much of it, just functions i wanted)
<beach>
What was your reason for doing that?
eli_oat has joined #lisp
Bike has quit [Quit: Lost terminal]
phax has quit [Quit: phax]
eli_oat has quit [Read error: Connection reset by peer]
eli_oat has joined #lisp
PinealGlandOptic has joined #lisp
rippa has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
wxie has quit [Quit: Bye.]
sauvin has quit [Ping timeout: 240 seconds]
<phoe>
Hm. FIVEAM:MAKE-FIXTURE and FIVEAM:MAKE-TEST are exported symbols but have no definition.
sauvin has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
<phoe>
Xach: are you able to post some fresh download statistics for Quicklisp?
<phoe>
Though, hm, the last ones are from two months ago. They are fresh enough for me.
SlowJimmy has joined #lisp
SlowJimmy has quit [Remote host closed the connection]
Kevslinger has joined #lisp
quazimodo has joined #lisp
fikka has joined #lisp
vlatkoB has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
PinealGlandOptic has quit [Quit: leaving]
fikka has joined #lisp
SenasOzys has joined #lisp
blurgh has joined #lisp
<blurgh>
Would Lisp being tree-based instead of list-based remove the need for CDR coding and other tricks to get it to run on bare metal?
<beach>
CDR coding is not required in order for Lisp to run on bare metal.
<aeth>
s-expressions *are* trees and afaik no modern implementation bothers with CDR coding
<beach>
blurgh: Nor any other particular tricks for that matter.
<blurgh>
beach: Right, but Lisp Machines did it to make it tolerably fast, didn't they?
<beach>
blurgh: No.
<beach>
blurgh: They did it to save memory.
tkhoa2711 has joined #lisp
<beach>
blurgh: Things like that are no longer needed.
<phoe>
blurgh: Mezzano runs fast enough on bare metal
reverse_light has quit [Ping timeout: 256 seconds]
<beach>
blurgh: There are at least two systems that run on bare metal. Mezzano and Movitz.
<blurgh>
beach: Movitz is dead, isn't it?
makomo has joined #lisp
<beach>
blurgh: It still shows that Common Lisp can run on bare metal.
<beach>
blurgh: Modern processors are perfectly capable of running Common Lisp perfectly well.
tkhoa2711 has quit [Client Quit]
johnvonneumann has quit [Read error: Connection reset by peer]
johnvonneumann has joined #lisp
<blurgh>
beach: True, but they're not designed for it. Technically, you could run a truely foreign language like Clean or something based on cellular automata, but would that yield appreciable speed? (OK, maybe Clean would be fast on bare metal given how fast it is already)
<phoe>
Define "designed for it"
<beach>
blurgh: SBCL is capable of generating very fast native code. I don't know where you get the idea that this is not possible.
<phoe>
They aren't designed for running Java either which doesn't prevent it from flourishing on x86_64 and more and more optimizations making its way into the JVM all the time
<beach>
blurgh: Furthermore, there is nothing special about running on bare metal. The same code generator can be used, with only minor modifications.
<phoe>
Has anybody picked up LET-PLUS from its unmaintainedness?
<beach>
blurgh: Or, perhaps by "bare metal" you don't mean "without any operating system", and instead you mean "running native code"?
<beach>
blurgh: If so, then it is already done, and has been for decades. Most modern Common Lisp system generate native code on the fly.
<blurgh>
phoe: C maps 1-to-1 to a Von Neumann architecture computer with a single core. Even if it's a lie now (multiple cores, parallel stuff, etc), it's still faster than any other language. Lisp can come close to C's speed, but can match it only with judicious use of "call 'dissasemble', optimize by hand".
<blurgh>
That's critical for things like context switches.
<beach>
blurgh: Where on earth did you get ideas like this?
<beach>
blurgh: Can you show us some reference to the claim that Common Lisp "can match it only with judicious use of "call 'dissasemble', optimize by hand"?
<blurgh>
beach: messing around with it, every single benchmark I've ever seen. Lisp /is/ fast, but it's not C.
<phoe>
Sure thing, but raw machine speed at all costs, including programmer time, debugging convenience, no introspection and memory unsafety isn't what I'm after.
<aeth>
blurgh: It's easier to write an optimized compiler than to write hardware optimized for a language. So lisp machines arw forever dead, but Lisp runs well on modern architectures without a big mismatch
<beach>
blurgh: You are terribly confused.
<blurgh>
beach: look at the computer language shootout.
<beach>
blurgh: You are making claims about the possibilities, but you only look at existing implementation.
<aeth>
blurgh: C is fast because tons of money goes into C compilers and because C design chooses a low memory overhead and fast execution speed over literally everything else, including nice things like some degree of safety
<aeth>
In theory, a CL compiler that had as much attention could be as fast with (safety 0)
<aeth>
Or at least close enough
<beach>
blurgh: Furthermore, different languages are good for different things. Try using C for something that requires a lot of memory allocation, and you will see that malloc()/free() is much slower than any modern garbage collector.
<aeth>
blurgh: Pretty much the only necessary overhead CL is going to have is the GC
<blurgh>
beach: of course calling disassemble and then optimizing it will result in faster code. Doing this automatically at runtime with a JIT is why Julia is frequently as fast as C. aeth: yes, that's probably true. Stuff like bignums are expensive, but the Right Thing nevertheless.
<blurgh>
beach: I love Lisp and think it is a lot better than C.
<beach>
blurgh: Good. Then you should know that for programs that do roughly the same things in C and Common Lisp, then the speed is also comparable. The problem is that most programs don't do the same thing.
eli_oat has quit [Ping timeout: 256 seconds]
<aeth>
blurgh: CL doesn't need to be JITed to be efficient, except for maybe CLOS dispatch
<blurgh>
beach: Then why is it consistently slower in the Language Shootout and blog post tests?
<jackdaniel>
you can write code fast in Common Lisp and you can write fast code in Common Lisp
<jackdaniel>
doing both at the same time is easy
python476 has joined #lisp
<aeth>
blurgh: $$$
<aeth>
You can make any language fast with enough money. And what will get the money? Languages used by the industry.
dddddd has quit [Remote host closed the connection]
<aeth>
(The amount of money will vary based on the language, but getting good performance out of CL is probably easier than with JS.)
megalography has quit [Ping timeout: 240 seconds]
<jackdaniel>
blurgh: looking at these charts CL *is* comparable in speed with C albeit slower
<beach>
blurgh: I already told you at least two reasons. A typical Common Lisp program will do more things than a C program because most C compilers exploit the fact that the standard allows them to elide things like boundary checks, whereas most Common Lisp compilers generate checks for such things.
<beach>
Furthermore, as I told you, the fact that Common Lisp is capable of being as fast, doesn't mean that current implementations (that are maintained by volunteers instead of by big corporations) live up to that capability.
<jackdaniel>
some adventages become obvious only after program goes above some complexity level
reverse_light has joined #lisp
<jackdaniel>
and it is easier to write fast maintainable non-trivial program in CL than in C
<beach>
blurgh: Again, you look at existing implementations, but you make claims about what is possible for the language as such.
<jackdaniel>
(in my personal opinion ;)
<jackdaniel>
and keep in mind, that I *do* like C for its simplicity and I use it actively ;)
<aeth>
Simplicity?
<jackdaniel>
yes
<aeth>
I like CL for its simplicity, but I guess I prefer syntactic simplicity
<cess11_>
What is "speed"? For whom is numbercrunching throughput the only interesting metric?
<aeth>
C is complicated. -> is an abomination
<beach>
blurgh: The real question here is whether it is worth programming in C where the programs are vulnerable to various attacks just to gain a bit of performance, or whether you prefer safe code to make you as a programmer more productive at the cost of a little more execution time.
<aeth>
cess11_: CL is actually a decent Fortran these days.
<blurgh>
jackdaniel: Yes, it is fast. Being within an order of magnitude of C is very impressive for any language. aeth: That's probably true. Nevertheless, Clean is faster than SBCL and only slightly slower than C, while being a rather general language implementation. STALIN and MLton both beat C, but are impractical. What structural features could be improved in Lisp?
<aeth>
CL has decent numerical optimizations.
<beach>
blurgh: Maybe you are just embarrassed about the language shootout? Did someone confront you with it, and you were unable to defend yourself?
<aeth>
blurgh: That benchmark isn't some objective measure of speed
<blurgh>
beach: C is unacceptable as a language for serious projects. That's why Lisp needs to be improved. And no, I'm just mulling over things. I've written my own Scheme and have generally been thinking about doing something new.
<beach>
blurgh: There are no improvements to Common Lisp required. What we need is more people to improve existing implementations. You keep confusing language and implementation. Maybe I am not being clear enough on that point?
<aeth>
(And some benchmarks are really just tests of FFI into fast C or Fortran libraries!)
<beach>
blurgh: I don't see why you conclude that Common Lisp needs to be improved.
<aeth>
blurgh: A CL implementation needs a quality real-time GC imo.
<jackdaniel>
blurgh: it is covered in one of PG essays – CL has numerous orthogonal features (which are gradually adopted to other languages as well; except maybe macros which are hard for non-sexp syntax) – the structural adventage is that these features support each other and may be used to improve the program
<beach>
blurgh: You seem to be convinced that Common Lisp needs to be improved, and that is what you also started by saying (tree based instead of list based, whatever that means), but there is no evidence to support this claim.
<blurgh>
beach: A lot of admirable work has been done in Common Lisp. It's something of a sum of what's been tried and what's failed in Lisp over the years.
<cess11_>
blurgh: So drivers and kernels and compilers aren't serious.
* phoe
goes to make some tea
<cess11_>
I look forward to your future achievements, I'm sure you will revolutionise computing science.
<jackdaniel>
in other languages, where you adopt some feature, it often feels off in it – it may be not well suited for it
<jackdaniel>
regarding improving Common Lisp – I wouldn't mind if remove-if-not had disappeared ;-)
<beach>
I would. :)
<blurgh>
beach: a tree-based language would be Refal. That's a weird one.
<aeth>
jackdaniel: Removing #'remove-if-not requires #'remove-if with #'complement to be optimized
<aeth>
Otherwise you're giving up performance
fikka has quit [Ping timeout: 248 seconds]
<jackdaniel>
I hoped that ";-)" will indicate a joke – removing a single symbol from CL standard wouldn't give us anything except rendering wide range of programs invalid
fikka has joined #lisp
<beach>
blurgh: Can you define what you mean by a "list-based language" and a "tree-based language". The only thing that is "list based" in Common Lisp is the representation of source code, and that has absolutely no impact on the performance of the generated code.
megalography has joined #lisp
<aeth>
jackdaniel: However, removing my list of 54 symbols would give us something.
<aeth>
/s
<aeth>
blurgh: Lisp isn't LISt Processing these days. It has arrays, structs, CLOS objects, hash-tables, first class functions, etc.
<aeth>
If you primarily use lists, that might be why you think Lisp is slow. Lists are... slow in Lisp. (Doesn't really matter if it's done at compile time with macros, though. Still compiles way faster than C++)
nika has joined #lisp
<aeth>
You're not supposed to use lists for everything, which is why they're very straightforward without clever optimizations
<jackdaniel>
blurgh: regarding structural differences: http://paulgraham.com/diff.html ; while PG doesn't like CL anymore many of his essays are good (he is a good writer)
vaporatorius has quit [Ping timeout: 240 seconds]
<jackdaniel>
"revenge of the nerds" has all these points listed in a more elaborate manner I think
<aeth>
I disagree. I liked his essays back in the day (2012 or so?) but I don't agree with many now.
<blurgh>
jackdaniel: I've read all of his essays. That's part of what got me into Lisp.
<jackdaniel>
so lets agree to disagree, getting back to my hacking :-)
<jackdaniel>
blurgh: cool :)
<aeth>
oh wait, diff is it
<aeth>
I thought it was called Roots of Lisp
<aeth>
Terrible URL system
lyding has quit [Ping timeout: 255 seconds]
<blurgh>
aeth: I know it has other features. Take a look at Refal. Between supercompilation and efficient term-rewriting, it's apparently always been very fast. It's something like a '60s Haskell that ended up on the wrong side of the Cold War.
<beach>
blurgh: So you are just not going to address the issues with you opinion, nor answer the question we asked, and just keep claiming that Common Lisp needs to be improved in order for compilers to be able to generate fast code?
<aeth>
blurgh: The core of CL is very efficient. Basic CL is just a bunch of thin macros on top of tagbody and go. It's... very close to how the hardware works.
<blurgh>
Really?
<aeth>
loop obscures it a bit more than the other ways to iterate, but dotimes and do are very straightforward if you macroexpand them.
<jackdaniel>
aeth: this is nonsense (sorry to say that out loud)
<aeth>
s/very close to how the hardware works/very close to how the assembly language pretends the hardware works/
<aeth>
I guess :-p
yoel has joined #lisp
<blurgh>
beach: What question? Why I'm asking this? I showed you 2 straight-up tests, and you said it was as fast as C. I said that it was within an order of magnitude (and that's still very good! It's akin to Java, which has had a lot more work put in) and only matches it with manual trial-and-error optimization.
<beach>
blurgh: Can you define what you mean by a "list-based language" and a "tree-based language".
<cess11_>
Java is a mess.
<beach>
blurgh: That's what I was asking you.
<cess11_>
beach: They mean that building a list from both ends at the same time matters in program efficiency post-seventies, I think.
Kundry_Wag has joined #lisp
<beach>
cess11_: I am specifically asking about the LANGUAGE, i.e. what it means for a LANGUAGE to be list based or tree based.
<aeth>
blurgh: Optimizing a modern CL AOT-compiled implementation is pretty straightfoward, actually. What fools the type inference is some built-in type-generic functions (not CLOS generic) for sequences and numbers like #'map and #'+ because for the rest, the compiler can usually infer that it's going to either be that type or an error (e.g. #'car or #'maphash)
<aeth>
blurgh: So when you use something like #'map or #'+, you're probably going to have to declare the type (or, more portably, use check-type) to make sure that the compiler has the information that it needs.
<cess11_>
Yeah, and I don't think they have any idea what -based could mean.
<aeth>
Oh, and arrays have an additional slowness of bounds-checking that can sometimes be avoided if the full type (which includes the length) is given.
<blurgh>
beach: a tree-based language is one like Refal - the basic structure is a list which can be built from both ends and pattern-matched down to be reduced by partial evaluation.
Pixel_Outlaw has quit [Quit: Leaving]
<blurgh>
beach: basically, the compiler already knows the properties of whatever's in the tree beneath a root expression and can optimize from there. There's also the Lorax language (experimental, idk if you can find the paper) which does something similar to generate efficient code.
yoel has quit [Ping timeout: 260 seconds]
<beach>
blurgh: And what makes you think that Common Lisp is "list based" then? More specifically, why do you think the fact that it is "list based" has an impact on performance? Also, what makes you think that it is not possible to use such a data structure in Common Lisp, should that be required?
<beach>
blurgh: So now you are talking about the performance of the compiler? As opposed to the performance of the code generated by it?
lyding has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<blurgh>
beach: In Lisp, you can have a list with a hashtable symbol, a tree symbol, and a graph symbol. Nevertheless, you still have to traverse it with car and cdr ultimately. It makes it much harder to optimize things away, like how many purely functional data structures can be built from finger trees and reduced to a common representation.
<beach>
blurgh: What on earth makes you think that one HAS TO program with lists in Common Lisp?
<beach>
blurgh: Do you seriously believe that the EXISTENCE of lists in Common Lisp determined the result of the language shootout?
<jackdaniel>
blurgh: you have just presented a very uneducated opinion regarding Common Lisp
<aeth>
blurgh: The typed lists are actually a bit slower, though. Maybe 20% or so.
<aeth>
You could probably make a typed cons (for trees) similarly out of that typed list macro fairly easily.
<blurgh>
beach: basically, alpha equivalence matters is all I'm saying. That allows a lot of funky optimization-by-substitution. Part of the reason why the fastest high-level languages are purely functional is becausing being purely functional lets you close the gap a little more.
<blurgh>
because it simplifies things for the compiler. Being tree based takes that further.
<aeth>
blurgh: Purely functional programming languages are going to be *slower* unless you're dealing with threads, afaik.
<beach>
blurgh: No, that is not all you are saying. You make sweeping claims that you then are unable to support by evidence, and not even by reasoning.
<aeth>
blurgh: Or at least enough people didn't buy into functional programming until multithreading took off.
<White_Flame>
aeth: In theory, a function language with a Sufficiently Advanced Compiler could convert things to mutating behind the scenes and achieve comparable speed
<White_Flame>
*functional
<White_Flame>
but really, those sorts of optimizations tend to happen at the application level, not the language level, so such a compiler concept is pretty out there
<blurgh>
aeth: Not true. Implicit parallelism is nice, but by that point, you might as well use C because parallel computations are all about C. The real killer is graph reduction (or closure reduction, which is what I've heard Haskell's STG uses). White_Flame: That's exactly my point. In fact, it's been done before in the '80s. It just required special hardware.
<aeth>
White_Flame: Yes, and they can for some things, but not for all things. For instance, you probably can't use a functional programming language for gamedev in 2018, even though in theory nothing's stopping you... because game architectures have enough unique requirements that not all of the smart compiler optimizations are there.
<cess11_>
C is a high level language. It has loops, variables, &c.
<blurgh>
are all about wrenching out that last bit of speed*
<aeth>
Anyway, nothing's stopping you from making a purely functional language *in* CL, afaik.
<aeth>
Macros are that powerful.
<White_Flame>
blurgh: well, you did say that functional programmling languages are the fastest, so shouldn't "that last bit of speed" already be considered? ;)
<aeth>
cess11_: It's the lowest of the high
<blurgh>
cess11_: I never made a claim to the contrary. PG talks about how Lisp proves Turing-completeness doesn't mean equality.
<aeth>
cess11_: Although I think the dividing line is whether or not you're working with registers.
<aeth>
blurgh: CL's cons and list are not optimized. That doesn't stop you from writing optimized functional lists/trees in CL... probably using structs if you really want maximum performance.
<White_Flame>
if FP languages truly are the fastest, then game programming would have embraced them 100%
<blurgh>
aeth: You're right. You could even make Haskell in Common Lisp; I think the earliest implementations might have been that. Does Haskell have macros? Does it have even half the flexibility of Lisp? Is there anything like SLIME for it?
<aeth>
White_Flame: Well, I said why they don't. They have specific needs.
<cess11_>
blurgh: You'll need to decide whether you believe 'C is the fastest' or 'the fastest are the functional languages'.
EvW has joined #lisp
<blurgh>
White_Flame cess11_: I take them as examples of fast high-level languages. Even they're usually 2-3x slower than C on stock hardware.
<aeth>
blurgh: Well, you can make a language like Haskell or like Python or like Java or whatevever in CL. Actually making an implementation of a specified language in CL, even Scheme, is going to cause problems when there are mismatches (e.g. Scheme has a separate #f and '() while CL doesn't)
<White_Flame>
"Part of the reason why the fastest high-level languages are purely functional..."
<blurgh>
White_Flame: I should have specified "very high level". C does straddle the line.
<White_Flame>
FP compilers, while they are a lot smarter now than they used to be, aren't going to compete for general purpose complexity
<blurgh>
my mistake.
<White_Flame>
because as I mentioned, they don't have access to the level of abstraction necessary
<aeth>
blurgh: That's circular because very high level is functional
Kundry_Wag has joined #lisp
<aeth>
(or some other form of declarative)
asarch has quit [Read error: Connection reset by peer]
<cess11_>
I'm still wondering to whom numbercrunching throughput is the only interesting metric. In my experience only those who never write code think it is but I'm sort of a loner amateur.
<blurgh>
White_Flame: Yes, they do. Haskell is just extraordinarily poorly implemented (monadic IO is an awful idea that should have been replaced by either FRP or uniqueness typing). They all make compromises where they shouldn't.
<jackdaniel>
I think we got into offtopic – please move it to #lispcafe which is better suited for such disputes
<White_Flame>
well, you seem to have a hammer that you think will nail the world's problems, without a lot of nuance or breadth...
EvW has quit [Ping timeout: 256 seconds]
<blurgh>
cess11_: I'd really like to see a competitive operating system in a high level language. That requires speed.
<White_Flame>
and even where there are a lot of FP-in-Lisp programmers here, you're not getting a lot of purcfhase
<White_Flame>
*purchase
<aeth>
blurgh: CL is a practical language. By the early 90s, the Lisp split was pretty clear between the practical/industrial CL and the research-focused, academic Scheme
<aeth>
Language features added to CL should solve practical problem.s
<cess11_>
blurgh: All the popular OS:es are developed in high level languages.
<blurgh>
aeth: I suppose you're right. Sorry about bugging you. cess11_: Do I have to say VHLL every time? lol
<aeth>
cess11_: blurgh means "very high level language", which depending on who you ask either means Prolog/Haskell/etc. or... anything higher level than C++ (anything with a garbage collector?)
<cess11_>
But I'm all ears, what is the competition you want to tackle with your high performance CL OS? Windows servers? MacOS laptops? Fuchsia phones of tomorrow?
<aeth>
blurgh: VHLL looks lke VHDL, which isn't a VHLL ;-p
<blurgh>
aeth: by the time you get to the level of Java, is it worth using anything other than Lisp from a purity standpoint? cess11_: I'd really like to see an alternative to Fuchsia. It looks like a lot more of the "same old, same old" Unix mantras which have led to disastrous hacks and failures.
<White_Flame>
define "purity standpoint"
<aeth>
blurgh: The answer is, unfortunately, always libraries and size of the development community. Combined that saves a ton of work, probably more than the greatest language can save you.
<blurgh>
White_Flame: If pointy-headed bosses didn't exist and we had all the libraries we wanted.
<aeth>
CL is probably the best language for solo projects where a lot of things are written from scratch. That... is not a common thing these days.
<cess11_>
blurgh: What parts of the Fuchsia project looks like a Unix to you?
<aeth>
Oh, and this is probably why pg is counter-productive. If you only care about productivity, you *won't* use Lisp, which... is kind of selling people the wrong thing.
<blurgh>
cess11_: It's written in C++. No-no.
JuanDaugherty has joined #lisp
<aeth>
s/which... is/which... means he is/
<cess11_>
blurgh: What Unix systems are written in C++?
<jackdaniel>
once again: please move this discussion to #lispcafe, it is offtopic and noisy
<cess11_>
Sorry.
quazimodo has quit [Ping timeout: 264 seconds]
<blurgh>
Sorry
<jackdaniel>
no problem, thank you for your understanding :)
* JuanDaugherty
agrees but notes that there really isn't a diff these days, same compiler normally
<aeth>
This is getting really off-topic but afaik only Linux had the strict no-C++ policy.
* phoe
puts aeth in #lispcafe and makes him some coffee
raskin[m] has joined #lisp
* JuanDaugherty
has some black beans and tuna and notes yeah it won't work with the kernel build
<blep-on-external>
"don't you think it's ironic people talk about static typing in a weakly [sic] typed language?"
Kundry_Wag has quit [Ping timeout: 248 seconds]
pjb has joined #lisp
wxie has joined #lisp
<beach>
makomo: That's a bunch of very smart and very knowledgeable people. That's why I get mildly irritated when some ignorant newbie comes here with claims that are silly and untrue, suggesting changes to the language based on false presumptions and false mental models of how things work.
<makomo>
blep-on-external: that was a good talk
Bindler has quit [Ping timeout: 264 seconds]
<beach>
blep-on-external: It's a war of words. The words "strong" and "weak" have an immediate psychological impact on programmers and decision makers. Therefore, the functional-programming crowd uses "strong" for what they do and "weak" for what we do. We counter by calling it "dynamic" for what we do and "static" for what they do. These words, have the opposite connotations.
<makomo>
beach: i completely agree and understand. i think learning common lisp was one of the best decision in my life, not only because of the language itself, but because of the whole history behind it
<blep-on-external>
fair enough
<blep-on-external>
i'm used to strong/weak being "can i make some value a garbage other value, like C casting?"
<makomo>
beach: all these papers, stories, posts, etc., truly a goldmine. newbs will be newbs though :^(
<blep-on-external>
static/dynamic to me is "can i pass different types to a function?"
<beach>
makomo: I agree.
<makomo>
but i can say i'm slowly spreading lisp around the people i know :-)
<blep-on-external>
eg the Haskell [YourTypeHere] is static, a Lisp cons is dynamic
<blep-on-external>
also i think Lisp is still a fantastic FP language -- partly cause it lets you write imperative code easily when needed and still keeping good style
<beach>
blep-on-external: You will notice this war of words in other contexts too. Scheme, for instance, calls the macro system "hygienic", implicitly categorizing that of Common Lisp as "dirty" or "unhygienic".
<pjb>
blep-on-external: lisp is still a fantastic OO language.
<pjb>
blep-on-external: lisp is still a fantastic declarative language.
<pjb>
blep-on-external: lisp is still a fantastic logic language.
<blep-on-external>
lisp is still a fantastic * language, i get it
<beach>
blep-on-external: recursion has its place, but pretty much only when tail recursion is not an option. When tail recursion is "natural", usually iteration is even clearer.
wxie has quit [Ping timeout: 268 seconds]
<blep-on-external>
usually. if i'm traversing some kind of tree, recursion works very well
<beach>
Indeed. For threes, recursion is perfect.
<beach>
But then, it is usually not tail recursion.
<beach>
And if it is, then iteration is even better.
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
<blep-on-external>
anyways, for another bollocks conversation starter:
<blep-on-external>
if lisp machines disappeared in the AI winter, why haven't they reappeared now AI is a popular research thing again?
<beach>
Like I said a few hours ago, modern processors are quite good for Lisp.
fikka has quit [Ping timeout: 248 seconds]
<blep-on-external>
i still think we can do better
<beach>
In what way would that be?
<MichaelRaskin>
To be honest, I think that the AI directions for Lisp machines are not what the modern AI boom is
vap1 has quit [Client Quit]
<beach>
That's true too.
<blep-on-external>
well, most interpreted languages today use some kind of stack-based VM
<blep-on-external>
yeah, Lisp machines did symbolic and logic stuff, not neural nets
<beach>
blep-on-external: How is that related to Common Lisp? Most modern Common Lisp implementation compile to native code, using the registers of the processor.
<phoe>
modern CL isn't interpreted
<phoe>
most implementations actually compile stuff
<beach>
blep-on-external: And there is no such thing as "interpreted language". Whether a compiler or an interpreter is used is related to the implementation, not the language.
<pjb>
Lisp hasn't been interpreted since 1962.
<blep-on-external>
ok, may i start again?
ealfonso` has quit [Ping timeout: 240 seconds]
<blep-on-external>
a lot of interpreting implementations for languages use stack based VMs. these are simple to compile for cause there's no register trickery needed
<blep-on-external>
instead of "put 2 in register #1, put 3 in register #2 and add #2 into #1", a stack VM runs "put 2, put 3, add them"
<blep-on-external>
the CADR machine did this with compiled Lisp
<blep-on-external>
compilers fit the processor, so modern compilers use a register model
<blep-on-external>
that's pretty cool actually
<phoe>
blep-on-external: if this is what you mean: yes, in theory you can create hardware that is highly optimized for CL
azimut has quit [Ping timeout: 264 seconds]
<blep-on-external>
i'd like an OpenCL version though that automagically converts vectors to OCL arrays and back
<phoe>
in practice: you'll need a person who'll have enough money, time and people to do it, and it is highly unlikely such a person exists
<MichaelRaskin>
Especially with the current hardware situation…
<pjb>
The current hardware is highly optimized for lisp, just like for C or any other programming language. Let's say it's a good local optimum.
<pjb>
The problem is not the hardware. It's the FFI.
<pjb>
It's the fact that you coded the kernel in C, and you have to interface to it and to a lot of userspace libraries written in C.
<pjb>
This is where all the difficulties and slowness lies.
<MichaelRaskin>
Per-language hardware optimisation might make sense if there is an actual niche where «twice as fast» is more expensive per-chip than «half as many»
<blep-on-external>
i'm not convinced the hardware is optimized for lisp
<blep-on-external>
the machine doesn't have a "symbol" type, "integer" type, "pointer" type or anything
<pjb>
The solution is to use a kernel written in lisp. cf. Mezzano, Movitz, etc, or participate into beach lisp OS project (planning stage now).
<phoe>
hardware discussion belongs to #lispcafe though.
<blep-on-external>
oh ok
<phoe>
let's keep this channel focused on Common Lisp.
<blep-on-external>
fair enough
DemolitionMan has joined #lisp
<JuanDaugherty>
the music on that video about common lisp made it sound like all those people were dead
Ukari has joined #lisp
<phoe>
JuanDaugherty: which video?
<JuanDaugherty>
the one pjb linked above
<JuanDaugherty>
i have a lisp OS windmill but in my thing, lisp is just a high level thing, a controlling image over a more or less standard linux
<MichaelRaskin>
JuanDaugherty: oh, a similarly jaded soul
Karl_Dscc has quit [Remote host closed the connection]
<blep-on-external>
i have a portable lisp interpreter kernel thingamabob which runs on Linux, C64 and DOS
<pjb>
Not posted a video here recently.
<JuanDaugherty>
oh geez, now I have to find it, it was a thing at stanford in '89
<JuanDaugherty>
sorry, thought it was one you posted, dunno where but it was obviously in last hour or so in some freenode channel
<pjb>
It was 30 years, they were in their 30s, so they're all retired now. Berlin wall wasn't down yet!
<pjb>
Make some such videos at the ELS, and watch them in 30 years :-)
<MichaelRaskin>
JuanDaugherty: is your windmill a pure windmill or are there any ideas I have a chance to grab for my layered system with Lisp for high-level control?
<JuanDaugherty>
it is not a pure windmill, but I have a lot of balls in the air
<JuanDaugherty>
but there's a possibility you could within a year
<MichaelRaskin>
Because I am slowly expanding what I control with Common Lisp
<JuanDaugherty>
i am refactoring, leveraging off of existing code, one CLOS app which shall remain nameless in particular
<phoe>
one language to control them all
<jackdaniel>
are we talking about C again? ;-)
random-nick has quit [Ping timeout: 240 seconds]
<phoe>
jackdaniel: yes, except this C has a little L afterwards
<JuanDaugherty>
no, I at least am talking about lisp OS
<MichaelRaskin>
I currently use Lisp to do the root-level control, and then I have some integration with StumpWM and I definitely embrace having multiple Lisp instances with different lifetimes and different OS privileges
<MichaelRaskin>
So if you are refactoring some preexisting CLOS application, maybe we have started from complementary directions anyway
damke_ has quit [Ping timeout: 264 seconds]
<JuanDaugherty>
well the core of my OS concept is to make a single system image using 9P stuffs
fikka has joined #lisp
<JuanDaugherty>
with the lisp image as the high level executive
<MichaelRaskin>
Hm
<MichaelRaskin>
In my case it would probably go from the other direction: if I use OS-provided jails and multiple interacting processes for everything, is there that much difference that some of them are not even local…
<JuanDaugherty>
first expressing an idea in a publicly logged channel is a kinda virtual NNDA
<JuanDaugherty>
public disclosure or whatever
wigust has quit [Ping timeout: 264 seconds]
<MichaelRaskin>
Well, in my case I have a public repository with the code I actually run
Quetzal2 has joined #lisp
<JuanDaugherty>
since I'm mostly refactoring and integrating it's not as quixotic as it might sound. I will make code available in my git repo to authenticated users of my domains
<JuanDaugherty>
as well as detailed design documents
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
<JuanDaugherty>
pjb, what percent of those people at the X3J13 meeting would say are in fact retired?
<JuanDaugherty>
*would you
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
Ukari has quit [Ping timeout: 255 seconds]
damke_ has joined #lisp
Kundry_Wag_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
milanj__ has quit [Quit: This computer has gone to sleep]
random-nick has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
janivaltteri has quit [Quit: leaving]
lnostdal has quit [Ping timeout: 248 seconds]
markong has joined #lisp
Jen has joined #lisp
SuperJen has quit [Remote host closed the connection]
damke has joined #lisp
Ukari has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
Kundry_Wag_ has quit [Ping timeout: 276 seconds]
shifty has joined #lisp
nika has quit [Quit: Leaving...]
yoel has joined #lisp
yoel has quit [Ping timeout: 248 seconds]
scymtym has quit [Ping timeout: 268 seconds]
zaquest has quit [Quit: Leaving]
dtornabene has quit [Remote host closed the connection]
zaquest has joined #lisp
nsrahmad has joined #lisp
Kundry_Wag has joined #lisp
scymtym has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
Kevslinger has joined #lisp
scymtym_ has joined #lisp
damke_ has joined #lisp
damke__ has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
damke has quit [Ping timeout: 264 seconds]
light2yellow has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
shka has quit [Quit: Konversation terminated!]
shka has joined #lisp
fikka has joined #lisp
nsrahmad has quit [Quit: Leaving]
light2yellow has quit [Quit: light2yellow]
fikka has quit [Ping timeout: 256 seconds]
<pjb>
JuanDaugherty: well, they look like they're between 27-35 so most of them would be today between 57 and 65. Furthermore, they're all american or live and work in the US, so retirement is more flexible, so I would say that none of them are retired yet. A few of them are already dead. Others are still working. Perhaps 30% are planing to retire in a couple of years, and the rest later. Now of course, you could use google and wiki
<pjb>
to get more information about the group, their age, and the current status. It would be more interesting to write an AI to do it for you. You could try wolfgan alpha on it perhaps?
<pjb>
wolframalpha.com I mean.
<pjb>
Not able. Neither is google. Perhaps facebook can do it, but I don't do facebook.
<pjb>
Perhaps the list of people in this meeting is already noted somewhere on the web…
<pjb>
But I don't find full listings.
vepsilip has joined #lisp
wxie has joined #lisp
Ven`` has joined #lisp
MasouDa_ has joined #lisp
Kundry_Wag has joined #lisp
MasouDa has quit [Ping timeout: 268 seconds]
dddddd has joined #lisp
<scymtym_>
phoe: you asked about let-plus. i did some maintenance work under the sharplispers organization. the improvements should be in quicklisp
<phoe>
scymtym_: yes, I found the sharplispers fork shortly afterwards.
<phoe>
Thanks!
<makomo>
pjb: it would be interesting to find the full list. i've recognized 3 people so far -- steele, kiczales and pitman
fikka has joined #lisp
<beach>
makomo: Very impressive! From where do you recognize them? Of the three, I have only met Pitman, but I am not sure I would recognize him in the video.
Bike has joined #lisp
<makomo>
beach: the internet, i've yet to meet another lisper in real life :-). both kiczales and pitman have a picture on their sites
fikka has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
<p_l>
makomo: then you need to visit Genova next year :D
<makomo>
who knows, it might just happen :-D
yoel has joined #lisp
rumbler31 has quit [Remote host closed the connection]
Naergon has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
<JuanDaugherty>
pjb, i would have inferred what you said as it has the ring of truth
<JuanDaugherty>
as far as SEs of today, ... .
wxie has quit [Ping timeout: 240 seconds]
<JuanDaugherty>
no doubt the thing is coming, prolly available to some extent and even google does pretty well if you have super chops for it
<JuanDaugherty>
i am 64 and I look forward to decades of work life ahead
<JuanDaugherty>
i imagine academics shed their class loads
<JuanDaugherty>
or even teaching entirely
<JuanDaugherty>
with exceptions
<JuanDaugherty>
that video aside, lispers don't exactly strike me as people persons
<vepsilip>
JuanDaugherty: its the lisp. we're self conscious...
<JuanDaugherty>
:)
<vepsilip>
:)
<vepsilip>
beyond that.... its not easy having super powers
<vepsilip>
sort of makes one an outcast
<p_l>
MichaelRaskin: one thing you need to take into account is that processes being remote *does* matter - you get to deal with network that might be much less perfect that intra-computer IPC
<MichaelRaskin>
p_l: depends on how remote. And I build everything around «experiment anyway, it's no problem if something crashes», which means that local IPC is also slowly adjusting the expectations
<Xach>
mfiano: gamebox-math doesn't build for me today
<phoe>
Xach: share logs?
<pfdietz_>
Xof: I actually found a use for user-defined method combination, in ansi-tests.
MasouDa_ has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
MasouDa has joined #lisp
<pjb>
JuanDaugherty: The ring of truth is always ±ε.
<pjb>
JuanDaugherty: and a function of time and place.
<JuanDaugherty>
pjb, did you see the Phillip Morrison series with that title?
<Xof>
user-defined method combinations, with :generic-function, possibly (particularly when used with user-defined generic function classes)
<Xof>
user-defined method combinations with :arguments?
* JuanDaugherty
believes in apodictic verities, and not just in mathematics
<pjb>
JuanDaugherty: for example, if you say that the sum of the angles of a triangle is π radian, then you're wrong. On Earth, it's greater, in general. Locally it can be smaller.
<JuanDaugherty>
well we risk the topic nazis if it can't be frame in a cl context
<pjb>
You would have to quote your axioms and your inference rules with all your sentences, to be able to say true tautologies.
<pfdietz_>
Xof: it used long form define-method-combination, but not :arguments or :generic-function. Although looking at those, I could see them being useful in my specific case.
EvW1 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<phoe>
Is it wise to (defmacro bar ...) (setf (macro-function 'foo) (macro-function 'bar)) to have the same macro definition under two distinct names?
<phoe>
Oh. It is not wise.
<phoe>
" The consequences are undefined if environment is non-nil in a use of setf of macro-function."
<Bike>
uh, but you don't do that?
<phoe>
...hmm, I have a null environment though. And the notes say that what I do is doable.
<Bike>
obviously setf macro-function is defined for a null env
<phoe>
Yep.
brendyn has quit [Ping timeout: 260 seconds]
<Xof>
pfdietz_: ok, that's interesting: a real-life example would be helpful
quazimodo has quit [Ping timeout: 256 seconds]
quazimodo has joined #lisp
yoel has joined #lisp
fikka has joined #lisp
<pfdietz_>
The method combination is called randomized. It invokes a random applicable method. The methods have weights that control their relative likelihoods.
random-nick has quit [Read error: Connection reset by peer]
<Xof>
so far so good
eli_oat has joined #lisp
<pfdietz_>
If I want a method to be able to fail and reinvoke the generic function, that would be a use case for the :generic-function argument (as I understand how that works).
<Xof>
ok, and if you want to call the gf with the same arguments, you'd need the arguments
<pfdietz_>
Yes. Or if I wanted to have some control over the random number generator, there could be extra arguments to do that.
<Xof>
something like &key random-seed?
fikka has joined #lisp
<Xof>
oh, wow, that actually does the Right Thing
<Xof>
you don't need to specify the required arguments in the :arguments form
<Xof>
(you probably do still need to have &allow-other-keys in the generic function)
<Xof>
hey, pfdietz, that's a "fun" ansi test: check that defining a method combination with a :arguments &key foo clause doesn't cause that keyword to be accepted by the generic function
<Bike>
i was going to say you could expand into (tagbody top ...however you choose... (call-method method (make-method (go top)))) to do "failure" by call-next-method, but the make-method form is evaluated in a null lexical environment
<Bike>
tragic
<pfdietz_>
I have no recollection of how complete the d-m-c tests were.
<Xof>
(arguably this behaviour is wrong)
fikka has quit [Ping timeout: 260 seconds]
<pfdietz_>
The methods always know the name of their generic function, so unless the failing is occuring in the method combination's glue code that use isn't a very good one.
DemolitionMan has joined #lisp
<Xof>
I wanted to implement a finite state machine method combination, using qualifiers as state labels
<Bike>
and what, a method return value is the next state?
<Xof>
but again it's not quite right, because the qualifiers are for compile-effective-method-time and the methods' return values are effective-method-run-time
<Xof>
Bike: yes
eli_oat has quit [Quit: Leaving.]
<Xof>
so far the most promising use of :arguments (for me) is information to affect the combination passed as an extra keyword argument
<pfdietz_>
Method combination for constraint satisfaction, where each superclass is a different kind of constraint.
<pfdietz_>
Method combination for implementing simulated annealing, where temperature is an argument.
<pfdietz_>
Method combination for executing methods in separate threads, where max # of threads is an argument.
broccolistem_ has quit [Quit: WeeChat 2.2-dev]
broccolistem_ has joined #lisp
broccolistem_ has quit [Client Quit]
kushal has quit [Ping timeout: 255 seconds]
broccolistem_ has joined #lisp
<wooden_>
i'm doing ncurses development, so running sbcl in another window and slime-connect'ing to it. i would like to use log4cl, but in addition to printing in the slime repl, it prints to the sbcl window as well, messing up the ncurses display. can i disable output to the sbcl repl? if so, how?
bjorkintosh has quit [Remote host closed the connection]
orestarod has joined #lisp
bjorkintosh has joined #lisp
<Bike>
log4cl probably lets you bind the output stream
<scymtym_>
wooden_: (log4cl:remove-all-appenders log4cl:*root-logger*) (log:config :stream SLIME-STANDARD-OUTPUT) where SLIME-STANDARD-OUTPUT is just *standard-output* if you execute the forms in the SLIME repl
broccolistem_ has quit [Client Quit]
broccolistem_ has joined #lisp
broccolistem_ has quit [Client Quit]
broccolistem_ has joined #lisp
<Bike>
i forgot you can't have multiple methods in the same group if they have the same level of specialization, which makes the whole exercise even mroe pointless than it was already
<orestarod>
anyone here having used cl-yacc?
<beach>
orestarod: You get better answers if you state your real question.
fikka has joined #lisp
kushal has joined #lisp
<wooden_>
scymtym_: thank you! totally works.
fikka has quit [Ping timeout: 248 seconds]
<makomo>
orestarod: i haven't but i've used esrap (scymtym's fork) and it worked well
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nika has joined #lisp
surya has joined #lisp
Ukari has quit [Remote host closed the connection]
Quetzal2 has quit [Remote host closed the connection]
fikka has joined #lisp
Quetzal2 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
jonh has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
Quetzal2 has quit [Read error: Connection reset by peer]
<orestarod>
my question regards cl-yacc and I want a clarification regarding whether it is possible to state precedence for prefix operands in my grammar
<orestarod>
makomo: I will look ino esrap too then
<orestarod>
scymtym_: I would need to rewrite my grammar in your parser. If I see no light from cl-yacc, I will switch to your work and maybe consult you after reading the docs. Thank you nonetheless! :)
<Bike>
eight lines to cover basic arithmetic seems a lot more convenient than yacc, though maybe it's hard to do in addition to non-expressions or something
scymtym_ has quit [Ping timeout: 260 seconds]
<orestarod>
What I am trying to do is more complex than simple arithmetics,though not too complex. I will provide the grammar if you wish to check for yourself and maybe tell me a few tips.
<Bike>
minion: message for scymtym: in the parser.common-rules readme, the link to architecture.builder-protocol in the "infix operators" section is a little messed up.
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
<phoe>
wait, seriously?
<phoe>
woah
<mfiano>
Yeah that's incredible
<phoe>
it is crazy
<beach>
Excuse my ignorance, but why is it "incredible" and "crazy"?
JuanDaugherty has quit [Quit: Ex Chat]
<phoe>
It did not occur to me that McCLIM is *this* ready for action
<mfiano>
Likewise, but moreso that something like this could be created in a such a short period.
<phoe>
^
easye has quit [Remote host closed the connection]
<beach>
mfiano: How do you know how long it took to create?
<phoe>
beach: Lisp Game Jam has a set duration.
<mfiano>
^
<phoe>
People can prepare their libraries in advance, but they start coding at a given hour of a given day and they must finish coding before a given hour of another day.
minion has quit [Read error: No route to host]
<beach>
I see.
specbot has quit [Read error: No route to host]
<jackdaniel>
McCLIM? 3d? hu hu
pierpa has joined #lisp
minion has joined #lisp
<mfiano>
jackdaniel: Thanks for the excellent work in McCLIM if I never thanked you (and all the other contributers too).
specbot has joined #lisp
easye has joined #lisp
python47` has joined #lisp
pierpal has joined #lisp
aabbcc has joined #lisp
<jackdaniel>
sure, I'm just cleaning some parts of the code - it is written by many hackers
<mfiano>
Who is working on the mezzano port?
<jackdaniel>
fittestbits, he hangs out on #clim and #mezzano
<mfiano>
Some months ago I saw that my pngload library was forked in preparation for the mezzano port, and I'd like to know if that ever got anywhere
<mfiano>
Ah yeah that sounds familiar
<jackdaniel>
well, as far as I know it works just fine on mezzano, I think he needs to tie some loose ends here and there and it will be merged upstream
<mfiano>
Great
<jackdaniel>
he was a little blocked by me, because I was refactoring mirror class hierarchy until two weeks ago
python47` has quit [Read error: Connection reset by peer]
<jackdaniel>
wow, this 3d game looks cool
<mfiano>
After the jam deadline (tonight/tomorrow depending where you live), everyone will have 4 days to play and then rate their favorites, so stop by again then :)
fikka has joined #lisp
SenasOzys has quit [Ping timeout: 264 seconds]
<jackdaniel>
I'll have to study the source code after the deadline
<jackdaniel>
but that will have to wait until I'm done with things (now I'm hacking on ECL and I'm learning Forth)
<MichaelRaskin>
Are these two things related?
<phoe>
jackdaniel: Forth for analyzing the ECL bytecode?
<jackdaniel>
phoe: that was the motivation, but I'm also interested in Forth itself
<MichaelRaskin>
Lisp reader macros for read-time Forth translation into Lisp, maybe
<jackdaniel>
MichaelRaskin: ECL's bytecompiler and interpreter are forth-like VM
<jackdaniel>
I want to learn the principles behind such systems
random-nick has quit [Remote host closed the connection]
<jackdaniel>
[I've got additionally inspired to learn it at ELS banquet ;)]
<phoe>
jackdaniel: how? (:
zotan has quit [Ping timeout: 256 seconds]
<Bike>
obvs should learn joy
fikka has quit [Ping timeout: 256 seconds]
damke has joined #lisp
<Bike>
has quotation, so it's basically lisp
<pierpa>
or Factor, which is basically CL reversed and with no parens
Kundry_Wag has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
vlatkoB has quit [Remote host closed the connection]
<jackdaniel>
phoe: discussion around the table with fourier and davazp
zotan has joined #lisp
SenasOzys has joined #lisp
random-nick has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
eli_oat has joined #lisp
eli_oat has quit [Client Quit]
python476 has joined #lisp
<phoe>
hah
<phoe>
the code I use to integrate PROTEST with 1AM is bigger than 1AM itself
shifty has joined #lisp
<flip214>
phoe: link to 1am? "protest 1am common lisp" doesn't find any useful hit ;/
<jackdaniel>
this is just small extension of 1am I needed
<jackdaniel>
but you may want to look at it since you are interested in 1am
<jackdaniel>
phoe: ↑
<phoe>
jackdaniel: I promise you that the next testing framework I create will be called HALF-PAST-TWO
<flip214>
phoe: I looked for "4", "5", and "6", each "pm" and "am", but couldn't find anything.
<flip214>
but never mind, you already told me what I needed to know!
<phoe>
flip214: (ql:system-apropos "FIVEAM") did the trick for me
<flip214>
phoe: but "5am" doesn't.
<phoe>
yep
ealfonso` has joined #lisp
<phoe>
jackdaniel: thanks for the heads-up, I'll think of integrating it with PROTEST based on my 1AM code
fikka has joined #lisp
kushal has quit [Write error: Connection reset by peer]
zooey has quit [Read error: Connection reset by peer]
<jackdaniel>
do whatever you please. I'm not planning to put it on quicklisp, I'm already confused with unit test frameworks we have, not going to make the problem bigger
<phoe>
well, in that case, I won't ,þ
kushal has joined #lisp
zooey has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
energizer has quit [Disconnected by services]
energizer has joined #lisp
energizer has quit [Remote host closed the connection]
energizer has joined #lisp
fisxoj has joined #lisp
l2y has joined #lisp
nika has quit [Quit: Leaving...]
light2yellow has quit [Ping timeout: 240 seconds]
yoel has joined #lisp
fikka has joined #lisp
l2y has quit [Quit: l2y]
light2yellow has joined #lisp
yoel has quit [Ping timeout: 260 seconds]
<Xof>
Bike: that (:method-combination machine) looks surprisingly sane. Doesn't use arguments or generic-function, though :-)
TCZ has joined #lisp
<Bike>
you can't have methods with different qualifiers but the same specialization
dxtr has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 260 seconds]
vepsilip has quit [Remote host closed the connection]
<Bike>
or at least sbcl complains... i don't know if it's defined
<Bike>
"If the two methods play the same role and their order matters, an error is signaled"
<Bike>
so really we'd like to have an infinite number of metnod groups. define method combination is not powerful enough, obvs
hhdave has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
fsmunoz has joined #lisp
<Xof>
I /think/ we decided that if the method group was * we would let it through
<Xof>
;;; It is reasonable to allow a single method group of * to bypass all
<Xof>
;;; rules, as this is explicitly stated in the standard.
<Bike>
oh, a single group.
<Xof>
yeah. Possibly we should extend that to any group with *
<Xof>
but you can make your machine method combination work with sbcl by making :start a method-combination argument
<Xof>
I think
<Bike>
yeah that kind of makes sense anyway.
rumbler31 has joined #lisp
v0|d has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 256 seconds]
barryfm has joined #lisp
comborico1611 has joined #lisp
TCZ has quit [Quit: Leaving]
random-nick has quit [Remote host closed the connection]
<Petit_Dejeuner>
Anyone want to reccomend a testing framework? I was just going to use lisp-unit or maybe 5am, but my reccomendations are 11 years old now.
<jackdaniel>
I find fieam pretty capable
<jackdaniel>
fiasco is very good too
<jackdaniel>
as of other gazzilion unit testing frameworks – can't tell. 1am is good for running tests by hand and stress tests
nckx has quit [Quit: Updating my GNU GuixSD server — gnu.org/s/guix]
EvW has joined #lisp
damke_ has joined #lisp
nckx has joined #lisp
asarch has quit [Quit: Leaving]
damke has quit [Ping timeout: 264 seconds]
pseudonymous has quit [Quit: Leaving]
yoel has joined #lisp
shka has quit [Ping timeout: 248 seconds]
sellout- has quit [Ping timeout: 255 seconds]
sellout-1 has joined #lisp
yoel has quit [Ping timeout: 264 seconds]
``Erik has quit [Ping timeout: 264 seconds]
fisxoj has quit [Quit: fisxoj]
zxcvz has quit [Quit: zxcvz]
matijja has joined #lisp
SlowJimmy has joined #lisp
ealfonso` has quit [Ping timeout: 260 seconds]
josemanuel has quit [Quit: leaving]
comborico1611 has quit [Quit: Konversation terminated!]
barryfm has quit [Quit: Ex-Chat]
Baggers has joined #lisp
kajo has quit [Quit: WeeChat 2.1]
kajo has joined #lisp
SlowJimmy has quit [Quit: good bye cruel world]
JohanP has quit [Ping timeout: 264 seconds]
nowhere_man has quit [Remote host closed the connection]
slyrus has quit [Ping timeout: 240 seconds]
nowhere_man has joined #lisp
slyrus_ has quit [Ping timeout: 264 seconds]
makomo has quit [Ping timeout: 256 seconds]
dented42 has joined #lisp
jlarocco has joined #lisp
JohanP has joined #lisp
slyrus has joined #lisp
epony has quit [Remote host closed the connection]
terpri has joined #lisp
epony has joined #lisp
slyrus_ has joined #lisp
JohanP has quit [Ping timeout: 240 seconds]
varjag has quit [Ping timeout: 264 seconds]
Baggers has quit [Remote host closed the connection]
pierpal has joined #lisp
ym has quit [Quit: Leaving]
hhdave has quit [Quit: hhdave]
matijja has quit [Ping timeout: 255 seconds]
python476 has quit [Remote host closed the connection]
JohanP has joined #lisp
Karl_Dscc has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
Quetzal2 has quit [Read error: Connection reset by peer]
shifty has quit [Ping timeout: 240 seconds]
matijja has joined #lisp
JohanP has quit [Ping timeout: 240 seconds]
fsmunoz has quit [Ping timeout: 256 seconds]
orestarod has quit [Quit: Leaving]
JohanP has joined #lisp
JohanP has quit [Ping timeout: 264 seconds]
random-nick has quit [Ping timeout: 264 seconds]
lnostdal has joined #lisp
JohanP has joined #lisp
broccolistem has quit [Quit: WeeChat 2.1-dev]
broccolistem_ has quit [Quit: WeeChat 2.2-dev]
broccolistem has joined #lisp
JohanP has quit [Ping timeout: 268 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dcluna has quit [Ping timeout: 240 seconds]
yoel has joined #lisp
yoel has quit [Ping timeout: 240 seconds]
comborico1611 has joined #lisp
t0adst00l has joined #lisp
quazimodo has joined #lisp
pmc_ has joined #lisp
brendyn has joined #lisp
z3t0 has quit [Quit: ZNC 1.6.3+deb1 - http://znc.in]
JohanP has joined #lisp
comborico1611 has quit [Quit: Konversation terminated!]
z3t0 has joined #lisp
JohanP has quit [Remote host closed the connection]
JohanP has joined #lisp
doanyway has joined #lisp
t0adst00l has quit [Read error: Connection reset by peer]
JohanP has quit [Ping timeout: 256 seconds]
t0adst00l has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
<pfdietz_>
I've found it useful to run unit tests repeatedly in random order. In systems with hidden state this can expose bugs. Found a bug in clisp doing this.