Introduction: Code == Code
Software has started to play an important role in our societies, and is becoming a structuring element in the public domain. For example, big data analysis has started to inform policy making; smart city software now executes policies and monitors behavior in cities; and websites and apps provide government services to citizens. Similarly, online platforms orchestrate various forms of interaction between governments and their constituents – from consultation of citizens in urban redevelopment processes to granting of licenses.
Software has thus become a vital form of infrastructure in our democratic societies. In that capacity, it is not just a tool that facilitates. Software has started to play a role in the political process itself as it has become increasingly entangled with policy. It can execute particular policies, and function as a monitoring agent and enforcer of policy. It can even produce new policies, for example when algorithms play a role in deciding which districts need extra policing or social services, which citizens are eligible for extra support or which citizens’ activities should be further scrutinized. Thus, software can no longer be considered as just another productivity tool, like a word processing suite or email client.
This means that software design is now directly related to processes of legislation and regulation. The calibration of algorithms and decisions on the types of data used for their input has consequences for policy making, its execution and control. Options presented in interfaces and visualizations define frameworks of interaction for civil servants and citizens.
In other words, increasingly code == code, meaning that software code has become inextricably intertwined with legal code. Computer code is now set to operate on policies that through democratic procedures have been codified in legal code. Both forms of code set conditions for society to function according to democratically set public values - the latter executed and interpreted by humans, the former by machines. In that guise, software has become an active agent in the organization of democratic societies. The ways in which software operates are based on rule sets, organizational goals, ideological preferences and cultural assumptions embedded in its code.
This means that software operating in the public domain should comply with the principles of democratic governance. Software cannot be a black box, ordered from outside companies that keep its underlying logic hidden in proprietary codebases. Instead, governments need technological sovereignty, enabling them to set and control the functioning of city software, just like they are able to set and control policy that is legally formulated in laws. At the same time, citizens and civil society actors need this software to be transparent and accountable. The design of software as an essential public infrastructure should honor a series of digital citizens’ rights. Apart from transparency and accountability, it should comply with public values such as inclusiveness and have a non-discriminatory character. It should also be understandable for its constituents. Most proprietary software systems that cities are currently using in their operations do not fulfill these requirements.
Therefore, a transition is needed to what we have called public code. Public code is an early stage concept that refers to software built to operate with and as public infrastructure, and a set of arrangements that allow for its production. As such, it consists of two key aspects: a set of characteristics and standards with which public code should comply, and an ecosystem that allows for the design, implementation and upkeep of this software based on technological sovereignty.
This document is meant as a starting point for a research agenda that could further develop the concept and implementation of public code, based on a series of explorational workshops held with various stakeholders in the fall of 2018.
This research agenda presents the outcomes of three workshops organized by Vurb.Agency, the Amsterdam University of Applied Sciences and the Municipality of Amsterdam. The goal was to further develop the concept of public code, start shaping up a Standard for Public Code and lay the foundations for a new organization for the stewardship of public code, provisionally labeled The Foundation for Public Code. Participants in the workshops included various stakeholders and actors producing, working with and being affected by software run by local, regional or national governments.
The first workshop took place at the gov-tech and civic-tech centered International Code4all Conference in Bucharest. The second in parallel with the Smart City Expo World Congress in Barcelona, an event aimed at amongst others industries and governments. In a third workshop, representatives of civil society, software companies and research institutes convened in Amsterdam.
These workshops addressed three main questions:
- What are the current problems with software in public institutions / the public domain?
- What can be done about these issues, and which actors could play what roles in that process?
- What are the challenges that may prevent the implementation of these solutions?
During these workshops three different types of questions emerged.
The first is a further philosophical exploration of the concept. What are the fundamentals of public code, what values should it address and how are these related to core principles of democratic society?
A second set of research questions seeks to transfer these values to a set of concrete design principles on which public code should be based: what could a standard for public code look like, and which actors could take which roles in the implementation of these standards? And what are the boundaries of public code?
A third and last set of questions addressed the production ecosystem for public code. What kind of institutions, actors, roles and business models could establish the conditions for a flourishing ecosystem for the design, exchange and operationalization of public code?
Read the individual workshop reports.
Research direction 1: fundamentals of public code - frameworks for understanding the role of code in society
In recent years various governments (both at local and EU-level), civil society organizations, researchers and think-tanks have further developed their view on the role of technology in society. Technology – and particularly software – is no longer seen as a mere productivity tool, but as a performative actor that based on particular underlying values and principles sets the conditions for civic, social and economic interaction in various societal domains, including the public domain. This shift includes both a new understanding of software as a performative actor, as well as the emergence of normative frameworks that explore the values that the design and implementation of technology in democratic societies should subscribe to.
How to understand the role of code in society
From an academic approach, a number of theoretical perspectives have been introduced. In a post-phenomenological philosophy of technology, the mediating role of technologies is foregrounded to bring out the implicit politics of technological artefacts. Sub-disciplines such as software studies and platform studies as well as broader approaches such as actor-network theory (ANT) and science and technology studies (STS) bring out the political, economic and cultural principles operating within both computer code and the contexts through which code is produced and exploited.
The field of law has also taken an interest in understanding the role of software in the process of legislation, and the affordances of software and technological systems for the governance of democratic societies as well as the challenges they entail.
Together, they have started to lead to a new orientation on the role of software in democratic societies and they have started to produce key concepts on which further development of public code can be based. These orientations contrast with more quantitative rational perspectives of code as a mechanic translation of the will of decision makers. Similarly, some of these orientations can also be understood as a critical reflection on rational choice models originating in fields like business studies and economics.
Basic principles of software operative in the public domain
At the same time, various governments and think tanks have started to translate this vision of software as a performative actor in democratic societies into normative approaches. These have taken the form of actual design guidelines, manifestos and definitions of principles. Barcelona has published both a Policy toolkit for ethical digital standards and a Manifesto in favor of technological sovereignty and digital rights for cities. New York City, Barcelona and Amsterdam have taken the initiative for a Declaration on Cities for Digital Rights, while Amsterdam has launched a manifesto for ethical and responsible data use. An EU-level example is the Ethics guidelines for trustworthy AI.
In the workshops, three central themes have arisen in these normative approaches. The first theme is technological sovereignty, meaning that governments need to have full control over software development and its intellectual property (IP). A second one is public values, that is to find ways to secure that government software underwrites democratically set collective public values. A third is Citizen’s Digital Rights, which focus more on individual citizen’s rights such as privacy.
For the propagation of public code, these normative approaches and their concepts can be further developed. Policy with regard to public code implementation, production ecosystems and the actual code written should be based on a firm set of principles, concepts and understandings. These can play a role in societal debates and political discussions, and function as a base for the design and implementation of public code.
As mentioned above, this concerns both a further conceptual exploration of the status of software as a performative actor in society, as well as a set of values that relate software development to the core principles of democracy. Research here could be organized deductively as conceptual enquiry into values and concepts, or inductively, starting by mapping and aggregating core values and approaches in existing agendas, manifestos, projects, white papers etc. that relate democratic values to software development.
It could also be studied empirically by analyzing the ways various existing instantiations of software have steered democratic processes. And vice versa: how democratic representations such as city councils and governments are trying to establish democratic control over technological policy, such as through procurement conditions. How tech policy is politicizing across current ideological and political cleavages is also an area worth exploring further.
And finally, a speculative approach – testing out various possible future policy and legislative directions and visions by designing and deploying probes and prototypes.
Research direction 2: a standard for public code
The second research direction that emerged from the workshops was how to make the new understanding of software in the public domain concrete for software development and implementation in the public domain. Governments, software developers, citizens and other actors need concrete guidelines that translate the normative principles emerging in the debate on the role of software in democratic societies into a set of design principles. These can also be used to hold the functioning of software accountable. One option here is to formalise normative principles into a standard and certification system that governments and designers can follow.
The concept of public code does just that. It is meant as a set of characteristics and design principles for software that ensure that the design and implementation of software in the public domain is congruent with a set of basic principles of democratic societies.
During this research project, the Foundation for Public Code developed a first version for such a Standard for Public Code. It was derived from input in the workshops as well as from the concepts and principles that have surfaced in the various manifestos and ethical guidelines developed by local, national and supranational governments, as well as by think tanks on ethics. In April 2019 a first version (0.1.0) was publicly presented, with an open invitation to contribute to the further development of the Standard.
See the current version of the Standard for Public Code.
Formal procedures for establishing a standard
To further this process, three core themes need to be explored further.
First, a formal procedure is needed for the governance of such a standard. How and by whom can new values be added to the standard, how can amendments be made, and can particular values be taken off the standard? The process is currently an open one, where suggestions are requested by all stakeholders.
But at a certain point in time, this needs to be formalized in a governance model describing particular criteria, roles and rights for constituents to contribute to the development of the standard. What should such a procedure look like? And what type of organizations (e.g. the W3c or Mozilla Foundation) could set an example?
Setting values and attributes
Second, the format for the values and attributes needs to be developed further. How can values be operationalized and ‘tested’ for?
One aspect of this is the further development of attributes or a range of values. For example, is certification for public code a binary process (it either matches or does not match the criteria), or are the gradations, e.g. particular levels of publicness in the code that can be achieved.
Currently, criteria in the standard are described according to the Key words for use in RFCs to Indicate Requirement Levels as defined by The Internet Engineering Task Force, whereas evaluation for each criterion of the standard is explicated in a descriptive ‘How to Test’ section. These approaches need to be evaluated, further developed and translated into a more formal protocol for certification and validation of public code.
Boundaries of public code
Third, an issue that came up in all three workshops was that of the boundaries of the concept. As public code is an early stage concept, its exact boundaries still need to be established. At the moment, the Standard for Public Code focuses on the development of software in an open and transparent design process, yet in the future the standard could be developed further. The boundaries to be set lie somewhere on a number of continua, some of which were discussed in the workshops.
The applicability of the concept in terms of the ‘technology stack’. Is public code just concerned with one particular layer, e.g. the algorithm that prioritizes access to a particular public resource? Or should it be extended to all technologies and their protocols in the stack, e.g. should hardware like cameras and sensors gathering input also be public code certified? What about the protocols in the communication networks involved?
The domains to which public code can be applied. Is public code restricted to government software, and interactions between governments and citizens? Or is it a standard that can be applied (or even made mandatory) to all kinds of software that somehow plays a core role in the public domain? E.g. if commercial social networks are found to be crucial civic infrastructures for social organization and the public debate, does that mean that they too should (be forced to) embrace the principles of public code?
The types of values public code should articulate. One of the discussions was to what extent Public Code-certification should be limited to Citizen’s Digital Rights that are mostly procedural and related to basic foundations of democracy, such as accountability, transparency and privacy. Should Public Code also include a set of collective public values such as solidarity, equality of opportunities, emancipation or ecological sustainability?
The applicability of the concept in terms of production versus execution: is public code just concerned with a set of criteria that a particular software suite could be evaluated against when executed (e.g. is the working of the algorithms transparent)? Or should it extend principles of democratic governance to the production of software set in particular use contexts (e.g. public code always needs to developed in co-creation with all stakeholders, including non-users that will be affected by its implementation)?
The conceptual inquiry described above as well as evaluations of current projects could be used to further develop the boundaries of public code as a concept as well as the procedures for its actualization through a standard and formalization of its stewardship.
Research direction 3: a production ecosystem for public code
The principle of software as a vital element of public infrastructure requires a shift in the production and development of software. No longer can it be considered a commodity that can be ordered from a catalogue, like a piece of office furniture or even a word processing suite. If code == code, the development of both forms of code should integrated, rather than one following the other sequentially. At the same time the development of software code should be based on the principles of technological sovereignty as well as public values and citizen’s digital rights.
During the workshops, participants claimed that current practices of procurement and software engineering are prohibitive for the production of public code from this perspective. For example, in the last decade, public organizations that purchased complete software solutions have sometimes been surprised to discover that they can’t change their software to reflect changing policy or take advantage of new technology, don’t have access to their data as it’s locked in to systems and are asked to pay ever increasing license fees. A new production ecosystem is needed to avoid relations with software producers that come with such vendor lock-in as well as the black-boxing of essential public infrastructures in proprietary software.
The emergence of such a new ecosystem is complex. In the workshops and initial explorations of the research team, various aspects were brought up that need further inquiry and development.
The entanglement of policy and code
If software plays an important part in the execution and monitoring of policy, these two sorts of code need to be designed in an integrated way, rather than one following the other. In other words: computer code should not be understood as a mere ‘translation’ of legal code. Rather, the design of legal code should already take possible operationalizations in computer code into account.
For example, in the Netherlands, the Council of State has recommended such an integrated approach. This means that computer code developers should be part of the legislative process, and that laws and their explanatory memoranda should reflect to what extent operationalization through computer code is desirable, what public values are involved and how they can be mitigated.
This also means that documentation of computer code operative in the public domain should include the legal code that it is based on. How such a process of co-development could work in practice requires further experimentation.
Shareability and software engineering frameworks
An important aspect of public code is a desire for ‘shareability’. Ideally, applications for government services that are developed in one city should be easily implementable in other cities. This makes the production of public software more cost-efficient while at the same time opening up resources that allow for more robust and extensive development compared to a situation in which software is only developed for one constituency.
From a software engineering perspective, this requires a number of conditions. First, it leads to the question of to what extent public code would require a meta-framework from a software engineering perspective. Such a framework could embody basic citizen’s digital rights, and provide basic functionalities such as ‘public-code proof’ identification systems. At the same time, it would enable the development of various services and applications by third parties.
An example is the common ground framework currently under discussion by the VNG (Association of Netherlands Municipalities). This framework allows for modular development of applications building on a particular organization of services and datasets. Second, on the level of individual applications, ‘shareability’ entails a design structure that includes easily identifiable variables that can be adjusted to local situations – or changes in policy.
Procurement: from software engineering to software design
According to participants in our workshop, many governments still regard software as a product that they can buy as a one-off to solve a particular need. The whole procedure of procurement is based on these principles. Usually a government defines a particular issue or problem and based on that, defines a number of requirements and specifications that are tendered to third party developers. Once developed, vendors often hand over the software package to the local government, either continuing the upkeep of the software through a service agreement, or alternatively handing over the management to government officers. Usability and user testing are often low priorities in the requirements and development cycle. At the same time, this software is developed in a proprietary fashion, often leaving governments without access to the data that is generated by the system.
This ‘engineering approach’, in which specifications are set early in the process, lacks a more iterative development cycle in which specifications can be set and reframed through various iterations of a design in collaboration between the client, users and designers. Software development should be understood as a living process or as an ecology. It needs to be able to continuously adapt to shifting contexts. In turn, developers need to be part of learning development communities in which they can exchange knowledge, insights and learnings. Current procurement practices and their attribution of time to the design of specific requirements often prevent both external contractors as well as government officials from taking part in these communities.
This means that the system for procurement and software design should be partially rethought. One suggestion in the workshops was to move to outcome-based tenders or service-level based tenders in which the problem is described, rather than the solution. In all of the workshops, a need was articulated to develop software in an agile, open and transparent way.
Distribution, stewardship and support
In the workshops, the model of open source was often invoked as an exemplary mode of production and distribution that allows for both shareability and agile development. Yet at the same time its shortcomings were also acknowledged. Whereas open source fulfills requirements of transparency and openness, its production system is not always thought robust enough by local governments. Who is responsible for the production and upkeep of open source software packages? As was mentioned by participants, open source often does not have a ‘help desk’. Who can you call when something does not work? Or who can you sue if things do not live up to expectations? There is a lack of a broader open source network or community that can be recognized as a reliable and durable partner, setting frameworks and support networks that can guarantee long term quality and support.
This also hinders exchange of open source software between governments. A local government that has developed a local app is often willing to share its source code with other governments, but doesn’t want to be responsible for the implementation in other cities. What is needed then is an organizational infrastructure that can take care of stewardship and upkeep of code, and make it available for third parties. Such an organization could on the one hand make sure that the codebases it maintains fulfill a number of criteria with regard to the functioning of software in democratic societies, and on the other be able to advise on implementation of these codebases elsewhere.
Business model renewal
The production of public code also entails a renewal of business models in software production. Third party commercial software developers could play an important part in the development of public code. In essence, public code is a set of rules. Everyone who follows these rules can play a part in the production of public software. This means that the writing of code can also be provided by commercial companies.
However, one of these rules is that the codebase should be open source and freely accessible. That means that companies who produce public code should grant everyone a license to use, modify and redistribute the code however they want and in perpetuity; this implies a shift in the business models for software consulting companies. Their business model would no longer be based on the licenses they sell to access their IP-protected software, but could instead be based on hourly rated consulting fees.
At the same time, at a higher level, new organizational and business models are needed for the upkeep of organizations that can provide stewardship of public code codebases. Here we could possibly learn from business model renewal in other fields.
The role that software development has started to play in the functioning of democratic societies means that digital literacy is becoming increasingly important. For instance, if the development of software becomes part of the legal process from the very start of policy making, what skills would policy makers and legal professionals need?
The concept of public code builds on earlier attempts to create open source ecosystems around government technologies and software, such as the implementation of open source productivity suites in government offices. At times, this led to the rise of subsidized innovation ecosystems that created interesting business opportunities for companies, but not always the desired innovation. What can we learn from these arrangements?
This research agenda addresses issues and themes that were brought up during three exploratory workshops around the concept of public code, as well as initial explorations of the theme by the research team. It serves to give guidance to directions and themes for further research and development of the early stage concept of public code.
This further research can take many directions. On the one hand, it can serve as a starting point for a more general further exploration of the role that software has started to play in the shaping of the public domain in democratic societies. This would entail the further development of normative frameworks as well as ecosystems for the production of software that ensure that the development and actualization of software in policy strengthens democracy rather than undermining it. On the other hand, this project has launched a Foundation and Standard for Public Code as one possible instantiation for such a values and stewardship framework.
In its present form this agenda mainly reflects the outcomes of three workshops with stakeholders in this subject matter and it does not pretend to be exhaustive, either in depth or breadth of the field. A number of the themes brought up here have already been taken up by various actors, albeit so far mostly not from the perspective of public code as an integral concept bringing these various areas of research together.
An important first step would be in-depth literature review and a categorization of current projects and their interrelatedness in the three research domains for public code.
The perspective of Fundamentals of public code requires further conceptual inquiry, working both deductively from theory as well as inductively from the recent emergence of various standards, manifestos and guidelines for citizens’ rights, public values or democratic principles in software.
With regard to the Standard for Public Code, future activities should concern the exploration of institutional arrangements through which the fundamentals can be translated into principles and evaluative frameworks for certification. Through these arrangements, stakeholders should start to discuss and evaluate the first version of the standard, and explore further development of its sub-concepts and criteria.
Research into a Production ecosystem for public code could center on various aspects, both in the form of pilots as in the establishment of more structured and institutionalized arrangements. It concerns, amongst others, exploration of business and license models, production cultures, as well as the actual software engineering, architecture and design around concrete pilot projects.