Pika: Empowering Non-Programmers to Author Executable Governance Policies in Online Communities

TL;DR

Pika tackles the barrier that online communities face when designing custom governance policies by enabling non-programmers to author executable policies through a declarative, modular language. It combines a policy-component library with a form-based authoring interface that compiles policies into PolicyKit-executable code, bridging non-programmers and platform backends. User studies show non-programmers can author policies about 2.5x faster than programmers coding directly, with strong usability signals, while programmers recognize improved efficiency over the PolicyKit baseline. The work demonstrates that declarative policy authoring can broaden participation in governance design and support diverse, platform-agnostic policies across communities.

Abstract

Internet users have formed a wide array of online communities with nuanced and diverse community goals and norms. However, most online platforms only offer a limited set of governance models in their software infrastructure and leave little room for customization. Consequently, technical proficiency becomes a prerequisite for online communities to build governance policies in code, excluding non-programmers from participation in designing community governance. In this paper, we present Pika, a system that empowers non-programmers to author a wide range of executable governance policies. At its core, Pika incorporates a declarative language that decomposes governance policies into modular components, thereby facilitating expressive policy authoring through a user-friendly, form-based web interface. Our user studies with 17 participants show that Pika can empower non-programmers to author governance policies approximately 2.5 times faster than programmers who author in code. We also provide insights about Pika's expressivity in supporting diverse policies that online communities want.

Figures (10)

• Figure 1: Pika Overview. To enable users to articulate policies in a declarative language, the Pika authoring interface fetches community information from home platforms and loads policy components from the JSON library. After the authoring process, the system generates a policy in the form of declarative language and compiles it into executable code in PolicyKit.
• Figure 2: An Overview of Data Models. Extending PolicyKit's abstractions of actions and procedures, we further decompose a custom action into a base action and filters, as well as a custom procedure into a base procedure, decorators, and executions. Such decomposition also grants non-programmers more expressivity in articulating a policy. Here we present approaches for users to articulate their governed action and governing procedure in our declarative language.
• Figure 3: Definitions of Policy Components
• Figure 4: (left) A Policy Written in the Declarative Language. This policy is corresponding to users' configuration in Figure \ref{['overview of data models']}. For clarity, a boxed view is used instead of the actual JSON format. Note the references to variables (blue) and settings (red) in the channel and text fields of the executionSlackPostMessage. This execution is set to happen in the channel where the custom action happens and its message refers to the number of jurors and the number of final yes votes from the base procedure. (right) The Corresponding but Simplified Executable Python Code in PolicyKit. We generate the code by linking and formatting the code snippet for each mentioned policy component according to PolicyKit's requirements. The declarative language components and their corresponding code segments are color-coded for easy correlation. Similar to decorators in Python, the code of decorators is prepended to the code of the base procedure.
• Figure 5: Details of policy components. Policy components are designed in a similar pattern: the name serves as its unique identifier, while the description offers a detailed explanation for end-users. The settings stipulate the necessary user input, complemented by variables that facilitate cross-component references. Each policy component is also paired with a respective code snippet used to compile policies in the declarative language into executable code in PolicyKit.