6 ms·
This is a long time ago, but I remember coming across this competition when studying software architecture for my Diplomarbeit. IIRC, the Haskell solutions wer
by mpweiher 10y ago
This is a long time ago, but I remember coming across this competition when studying software architecture for my Diplomarbeit.
IIRC, the Haskell solutions were disqualified, and actually for good reasons. The competition was about architecture of the system, with the geoserver an example component. Notice that for example Rapide is an Architecture Description Language (ADL).
As far as I can tell, the Haskell team(s) only concerned themselves with the (purposely) simplistic/simplified functionality of the geoserver component, and not the architectural concerns that were the actual point of the competition.
Which, quite frankly, is something I see frequently from the FP community: declare that <complicated actual problem> is really <much simpler problem easily solved by FP>, solve the simpler problem that ignores almost all the real requirements, declare victory and go home.
- wyager 10y agoWhat you are saying sounds interesting but very vague. Do you have any more details? Nothing you are saying corresponds to the contents of the PDF, which seems like a fairy complete summary of the competition.
- mpweiher 10y ago> What you are saying sounds interesting but very vague. Yes, it is vague. This was 20 years ago. > Do you have any more details? If you read the text carefully, and strip it of the "we were so awesome and those idiots didn't understand just how awesome we were" you can actually see quite a bit of what I was saying in the text itself. For example: "... neither [of the authors] attended the kickoff meeting at NSWC". So it's not entirely surprising if (as I suggest), they weren't fully aware of the actual purpose [especially if, as the other paper suggests, there were relevant discussions that preceded the kickoff meeting]. Or the following: 'One observer described the solution as “cute but not extensible” (para-phrasing); this comment slipped its way into an initial draft of the final report, which described the Haskell prototype as being “too cute for its own good”' Again, the authors frame this as the judges not understanding how wonderful their solution was, i.e. "everybody else is an idiot". Well, maybe everyone else isn't an idiot, and maybe the evaluation had something to do with not really contributing to the actual software-architectural purpose, which in turn had something to do with the authors not being there for the kickoff meeting? Of course, I wasn't there either, but this sure is what it looks like to me. Here is another paper, which talks more about the original problem and purpose of the competition, which was to be a sample problem (with sample solutions) for software architecture: http://www.cs.cmu.edu/afs/cs/project/able/ftp/aegis-iwssd8/aegis-iwssd8.pdf http://www.cs.cmu.edu/afs/cs/project/able/ftp/aegis-iwssd8/a... I remember seeing a more comprehensive report, which also had larger code samples and talked about the disqualifications, but I can't seem to find it right now.
- wyager 10y ago> I remember seeing a more comprehensive report, which also had larger code samples and talked about the disqualifications, but I can't seem to find it right now. Well that's precisely the vague stuff you were talking about in your original post, so that's very unfortunate.
- the_af 10y agoI don't see this arrogance you claim. My reading of the paper is completely different. Nowhere do I see this attitude of "everyone else is an idiot"; the author is just stating the fact that the other participants weren't familiar with FP techniques. This is not insulting, it's a statement of fact. It was also not unexpected in 1994. The author singles out the use of higher-order functions as an elegant technique of which the other participants weren't aware, even though some of their languages actually supported it! This technique is precisely what another participant considered "too cute for its own good" -- even though today we know higher-order functions are hugely useful and relatively mainstream, enough that few devs would find them surprising. Another objection was that they couldn't believe the Haskell prototype was a finished executable program and not a top-level design document mixed with some pseudocode... which speaks a lot in Haskell's favor! To me, Paul Hudak actually sounds humble in his paper. He acknowledges the limitations of the experiment, he is careful not to say this "proves" anything, but is enthusiastic about what it suggests, i.e. that Haskell can be used for rapid prototyping with great success! I'd say this is an uncontroversial conclusion. It's unfortunate that you cannot back the claim that the Haskell solutions were disqualified. It certainly contradicts the paper, which shows the final scorecard by the review panel...
- swhipple 10y agoI think this may be the report [1]? It seems that their P1 did not meet the standards, due to miscommunication -- not language incapability, but they were able to correct it in P2: > It happened that some modifications and extensions to Reference 1 were agreed to at the experiment kickoff meeting at NSWC. Dr. Jones and Dr. Hudak were not informed of those extensions until after the completion and review of the initial draft of Prototype 1. [...] > Prototype 2: We believe that our Prototype 2 will be most comparable to the prototypes prepared by the other teams. This prototype satisfies all mandatory requirements of the problem as defined in References 1 and 2, and also incorporates generalizations to support anticipated future requirements. To accomplish this task, the original author of Prototype 1 made a number of modifications and enhancements requiring about five hours [...] P1 and P3 solutions are attached in appendices, along with some others. [1] http://www.cs.yale.edu/publications/techreports/tr1031.pdf http://www.cs.yale.edu/publications/techreports/tr1031.pdf
- eklavya 10y agoI find that statement hard to believe when so much complicated software in the industry is built using Scala/Haskell/OCaml not to mention so much of research. (STM is an example of how some complicated stuff is solved easily using FP). Why do you feel they avoid real problems? When did you see that?
- oconnore 10y agoOne time someone posted a "concurrency challenge", and I spent a couple minutes typing out the STM calls that solved it. They balked, for some combination of: that doesn't work in C++, you're not really following the spirit of the challenge, etc. Later they posted a 100+ line solution using condition variables. Lesson: the "real requirements" typically include that the solution doesn't require learning anything new or weird.
- mpweiher 10y agoYes, that is true, and I sympathize, I am also often in the position of having a solution that is simpler than seems possible to the "less enlightened". However, "real requirements" often do include relevant things that aren't stated. I don't know if this was the case here, but "concurrency" is often something you need because of "performance", and so a Haskell STM solution may not be what your C++ hacker is looking for. The prime example of this is the Haskell "Quicksort" implementation, which is, of course, not actually quick and only vaguely related to the idea of Quicksort. Another example was SPJ's talk about parallel programming in Haskell, where the result was that a 6 core Haskell version was equivalent to a single core C solution. In the same talk he also boasted that "this is only possible with Haskell", to which an audience member replied that the HPC community had been doing this for well over a decade with FORTRAN. The problem with the FP community is that there is so much of the latter examples going on that the true cases of the former tend to be less believable.
- dualogy 10y ago> The prime example of this is the Haskell "Quicksort" implementation, which is, of course, not actually quick and only vaguely related to the idea of Quicksort. Yeah but at least it's lazy! ;) If you only ask to (sort) because from the result you're going to (take) the say 4 (smallest/latest/whatever-est), it'll only just sort-enough to give you these 4 sorted, unneeded values being discarded (usually) partially unsorted --- no matter the size of the total. (Still, there may no doubt well be better quicksorts for Haskell out there..) Of course you can write this sort of specific short-cutting in any language manually, but with lazy-evaluation it's just the standard behaviour for any naive `(take 4 (sortBy mysorter mydata))`-type expression. (Takeaway regarding "quick" above: everything regarding performance and efficiency in lazily-evaluated pure functional languages depends to a large degree on the current live data; predictability gets harder here consequently.)