Games people play

[John Reimer]

On Thu, 28 Sep 2006 13:34:15 -0700, Walter Bright  
<newshound at digitalmars.com> wrote:


>> also as a big fan of QT, Id like to request a S&S mechanism; or some  
>> sort of messaging pattern in the language. I think this would take D  
>> "over the top!"
>
> While I appreciate and enjoy the enthusiasm, this is deja vu all over  
> again. My entire career in compilers (C, C++, D, Javascript, etc.) I've  
> heard people say that "if only you implemented X, it will open the  
> floodgates!" It never does, but what does work is to work with people  
> who are *already* D users who are blocked by the lack of something. With  
> S&S, I'd like to see first how far it can be pushed with existing D  
> techniques.


I have to agree with this. S&S seems like a great pattern, but I'm worried  
about the urge to implement the current fads into the language just  
because they're "so great".  Someday, the excitement may fade when an  
improvement on the pattern surfaces, and we could be left with a feature  
in there that takes on a form altogether vestigual.  Of course, this is a  
risk of many language components, but I think D has to slow down on  
feature additions for awhile to let alternate solutions aggregate (a  
stress test of the language of sorts).

Nonetheless, it would certainly be fun to explore syntax alternatives for  
S&S,  just to see what it would be like.  I suppose if the pattern were  
generic enough, it could be interesting.

Another note, I've been reading up on S&S, and while its a fascinating  
pattern (although I dislike the signal/slot naming convention -- it seems  
to describe the solution unintuitively), I wonder how well it mixes with  
concurrency patterns.  I mean, we should really be looking at the broader  
application of it.  It really should have a combined application with  
concurrency.  That said, I noticed that CSP, which deals with  
"message-passing" and interprocess communication through "channels" has  
similarities to S&S, except in the context of concurrency.  Newer  
experiments in CSP have been exploring the passing of  
processes/threads/functions in addition to data... while here we are  
talking about concurrency, S&S appears to be messaging of a similar sort,  
except that it doesn't describe the threading domain.

Since concurrency is becoming such a hot issue, I really think we have to  
look at the broader scope of S&S in this context (I believe Qt S&S is said  
to be thread-safe while the boost alternative is not).  Is anybody here  
able to share how threading works with S&S?  Is it complicated?  Is in  
cleanly integrated?  I really think these two ideas should merge together  
cleanly... perhaps it can be done with a CSP implementation.

-JJR