[hybi] Protocol simplicity and the "amateur programmer" standard

[Maciej Stachowiak <[e-mail]>]

I recently had an IRC discussion with Ian Hickson about the "amateur programmer" standard, and what level of programmer simplicity we should strive for: <http://krijnhoetmer.nl/irc-logs/whatwg/20100725#l-92>.

Personally, I think the "amateur programmer" standard is a misguided goal, for the following reasons:

1) There is no example of any protocol ever that had significant deployment, where even casual programmers of simple programs would regularly implement it from scratch. Even for fairly trivial protocols like IRC, most people use libraries or stock implementations. Given the lack of existing examples of a protocol that amateurs actually implement, it may be that it's fundamentally not possible to design such a thing. It would be foolish to try to do the impossible. And even if it is possible but no one has yet succeeded, it is risky to experiment like this when the stakes are high.

2) I think a large part of the complexity in implementing a protocol truly from scratch (with no help from libraries) is the need to use extremely low-level primitives like Unix system calls. Use of very low-level primitives like socket(), bind(), listen(), accept(), read() and select() is likely beyond the capabilities of a true amateur or casual programmer, even for the most trivial protocol. Even for those who are able to correctly use these kinds of primitives, they likely would prefer to use a library or server framework for a casual project.

3) My supporting evidence for #2 is that in the case of nearly any kind of programming problem, when there is a choice between building from scratch with very low-level primitives and using higher-level APIs, casual programmers almost always choose higher-level APIs. I can't think of any instance where it's common to do otherwise.


Faced with these arguments, Ian proposed an alternate standard of "Keep the protocol as simple as possible to limit the number of bugs that professional programmers make." Ian thinks this is effectively equivalent to the "amateur programmer" standard, while I and likely many others on the list would expect there to be material differences. 

For one thing, I think it will be much easier for us to evaluate complexity against this standard. I don't think we have any true casual programmers on the list. While some active participants do not primarily do programming for a living, everyone here is an outlier in technical expertise, particularly in the ares of networking and Web technology. On the other hand, we have a number of people who work as implementors of network servers, networking libraries, and network-related middleware. It seems more sensible to me to pick a standard that we can directly evaluate based on the experiences of Working Group members. It makes more sense to me to evaluate our own understanding than to try to imagine what things are like for others.

To sum up, would anyone object to the following as a standard for protocol simplicity, in place of the proposed "amateur programmer" standard:

* Keep the protocol as simple as possible to limit the number of bugs that professional programmers make.


Regards,
Maciej