Software development is ultimately a social experience. And I’m not just talking about teams of coders. Even sharing or using code via library, or services via API, is a social experience involving communication and relationships between humans.
Consequently, there exists a vast array of social concerns surrounding the development experience: discovery, configuration and adaptation, maintenance and upgrade, safety and security, packaging and distribution, trust, reputation, blame, spam, licensing, market integration. If some of these aren’t obviously language-design concerns today, it is only because we have humans doing most of the footwork. Today, we human developers must purchase, upgrade, package, configure, track licenses, point fingers, and slog through spam. Greater automation and finer granularity will inevitably require a more formal and explicit representation of social policy.
Social concerns should be addressed in programming language designs. My reasoning is thus: Most code and services I use come from strangers. As years pass, I become a stranger even to my own code. An effective social model for programming should lower the barriers and improve confidence in using code and services developed by strangers. I posit that addressing social concerns does more for usability and productivity than addressing `cognitive concerns` (of the individual developer) because social elements will pay for itself manyfold due to network effects. (That said, I do not believe there are many conflicts between social and cognitive design considerations.)
A language designer should consider such cases as how the module system, type system, and namespace model influence the developer’s social experience. Is it easy and efficient to integrate code that uses a set with code that uses an array? Can developers effectively compose services that use heterogeneous data models? Is it easy to take code written for GTK and reconfigure or adapt it to use QT? Is it easy to track old configurations for regression testing? How much effort is required to disentangle a useful function or subprogram for use in other projects? Is there any mechanism for cross-project refactoring? Will developers easily experience `dependency hell`?
Security lowers a social barrier, mitigating need for `trust` or vetting code in advance. An expressive basis for security (such as object capability model) can also express and enforce interesting social policies within the language and thereby address many social concerns (e.g. Horton protocol).
It might help to have a vision for the social development environment. I have an idea in my head of a Wiki IDE concept as the basis for code sharing and discovery (and also a live projects on the cloud), with a DVCS-like mechanism to move code between wikis.
Unfortunately, there seems to be a lack of control-tested and empirically validated social models for addressing PL design in particular. I’ve not read of any `social dimensions of notation` to mirror Thomas Green’s `cognitive dimensions of notation`.
My own social design efforts are consequently `principled` in nature. Principled design is by no means scientific. It is an even mix of art, reasoning, intuition, and hypothesis, seasoned with a dash of idealism. But it works well in principle. Here are some resources from which I draw guiding principles:
- Ka Ping Yee’s Secure Interaction Design
- Research on ambient intelligence and ubiquitous computing.
- Research from the CSCW community
- The wiki design principles.
I don’t expect anyone to share my preferences for principles. But I would like to see more arguments considering the social aspects of PL design.