Introduction

This manuscript tackles a recurring problem for researchers in the peace science community. True research reproducibility is best achieved creating data from scratch, though no published guide exists that informs researchers how to do this on their own. Instead, researchers may end up reusing old code generated in past studies, leaving them to spend time and energy adjusting the sample of states, the temporal domain, and doing whatever additional troubleshooting may arise from this practice. Researchers may additionally spend too much time reproducing old code for standard information that goes into any dyadic or monadic analysis—like contiguity relationships and democracy—and have to do additional troubleshooting for how these various data sources treat missing data or treat state codes in a manner inconsistent with the more accessible Correlates of War or Gleditsch-Ward state codes. This is all compounded by changes in technology that treat the creation of the data and the analysis of data as a continuous process in which the contemporary quantitative political scientist is increasingly becoming a computer programmer as well. Graduate students and other beginners in the field face unique challenges associated with these developments. Students just learning peace science must learn how scholarship informs data in peace science and how data inform scholarship at the same time they are needing to learn quantitative methods in a chosen software package.

{peacesciencer} addresses these problems. Built around the free and open source R programming language, {peacesciencer} contains a suite of data and functions for creating data of interest to researchers. Researchers can use {peacesciencer} to create dyad-year, leader-year, leader-dyad-year, and state-year data (among some others) from scratch. Afterward, they can add a variety of standard information (e.g. contiguity, alliances, major power status, GDP per capita estimates, capability estimates, and more) to these data with a simple command. This is a considerable time-saver since, in the absence of it, researchers would have to more meticulously code and transform the raw data to conform to the kind of data they want. {peacesciencer} comes with some data innovations as well, including a comprehensive data set on democracy by year, an original data set on capitals and capital transitions, and a function to create peace years between ongoing conflicts. All are done with the maximum possible transparency. The project is available for public view on Github (https://github.com/svmiller/peacesciencer/). The data-raw directory on the project’s Github contains information and comments about how every data set was created. The function manuals (http://svmiller.com/peacesciencer/reference) contain additional comments about what each function returns and, in appropriate cases, why it is doing what it is doing. Thus, {peacesciencer} not only assists a peace scientist with their research, but it does so in a manner that best conforms to the Data Access and Research Transparency Initiative (DA-RT) initiative across all political science.

This data feature proceeds in the following fashion. The next section expands what need this package fills for peace scientists. Afterward, it provides an overview of what is included in {peacesciencer} to help researchers more quickly conduct the kind of quantitative research they want. Thereafter, it provides a tutorial on how to install and best use {peacesciencer} in the R programming language. A more comprehensive tutorial follows, showing how {peacesciencer} already has a suite of data and functions that can allow for effective replications of a “dangerous dyads” type analysis (Bremer, 1992), standard state-year analyses of civil conflict onset (e.g. Fearon & Laitin, 2003), and even leader-year analyses of inter-state dispute initiation (e.g. Horowitz & Stam, 2014). This feature concludes with a comparison of {peacesciencer} with other alternatives and a discussion of how {peacesciencer} can inform more reasoned design decisions for researchers in peace science.

Why {peacesciencer}?

{peacesciencer} is motivated by the following observations and ideals that led to its creation. For one, researchers invest too much time in the construction of a data set that faithfully captures the unit of analysis. Assume a researcher wants an original data set on all directed dyad-years for Correlates of War states for an analysis of inter-state conflict. How might one do that? The answer has never been immediately obvious. No published guide exists that shows a researcher how to create these data themselves from scratch, which is one reason why software bundles like EUGene and NewGene are attractive to researchers who primarily care about the substance of their research question. After all, EUGene’s main value—if not its primary impetus—was allowing researchers to create data sets for replication of previous studies, producing a host of data types (e.g. dyad-year, state-year, dispute-year) along the way that users can amend as they saw fit. {peacesciencer} is primarily born from this question about how to create these data from scratch. The underlying code that produces these data types is available online and {peacesciencer} converts these lines of code into simple functions for the ease of the researcher.

Second, researchers also invest too much time in retracing steps for peace science analyses for new projects. Assume a researcher finished a state-year analysis on the correlates of civil conflict onset a few years ago and wants to start a new project that analyzes the same outcome from a different angle (or perhaps using newer data). Under these conditions, a researcher will have to find where they stored that replication code and copy-paste it into a new directory for the new project. They may then have to change the name of some files, change some code to account for potentially new column names in the newer data, and troubleshoot instances where their old code does not perform as it once did. At its worst, this process may lead to some errors by the researcher. At best, this is tedium that spends the researcher’s time they would rather invest in analyzing the data. The lion’s share of {peacesciencer}’s functionality is both creating the units of analysis for the researcher and merging in different forms of data in wide use in the peace science community so that the researcher can spend less of their time on tedium.

Third, the creation of the data and the analysis of the data are increasingly becoming one continuous process. Not too long ago, it used to be the case that researchers had to download a data set, or create one from scratch (possibly in a spreadsheet or through a program like EUGene). After downloading or constructing the data, the researcher then opened a specialty program for statistical analysis (e.g. SAS, SPSS, Stata) to recode raw data into a form suitable for analysis before running a statistical model that regresses some outcome on a set of covariates. Current research practices still resemble this process, but the steps between them are no longer as large as they were in the past. Software options exist that allow the researcher to load data, create data, clean data, analyze data, and present the results of the analysis all within one program. {peacesciencer}, by itself, does not do all these things, but it seamlessly connects the beginning of the research process to the end of the research process without needing to leave the increasingly popular R programming language and RStudio (its free-for-use integrated development environment [IDE]).

Fourth, it is increasingly the case that as the steps between creating data and analyzing data decrease in size, the lines between them blur as well. In other words, to create data is to code data and the contemporary quantitative political scientist is increasingly becoming a computer programmer (c.f. Bowers & Voors, 2016). This is happening concurrent to innovations in programming languages for statistical analysis, especially the R programming language that {peacesciencer} uses. There have been significant advances in add-on packages that allow users to do things like get World Bank data from the internet (Arel-Bundock, 2021a) and even format results from a statistical model for presentation in a way the reduces the probability of transcription errors to almost zero (Arel-Bundock, 2021b). {peacesciencer} embraces this. This R package reduces the time required to create peace science data for analysis and also informs the user about the code required to create the kind of data the user wants.

Finally, the creation and presentation of data in peace science should be 100% robust and transparent, which {peacesciencer} takes seriously in the following ways. The website for {peacesciencer} has several vignettes that describe its processes in some detail. These include how it provides reasonable estimates of democracy that may not be available in the Polity data or the Varieties of Democracy data and how a researcher can whittle dyadic dispute-years into true dyad-years through reasonable case exclusions. {peacesciencer} subjects itself to a battery of tests before publishing updates, making sure new features do not create duplicate entries in the original data (which is the surest sign of a botched merge). The project’s Github contains a publicly available data-raw directory that shows how every data set included (and processed) in {peacesciencer} was created. The function manuals included {peacesciencer} contain ample documentation that clarify what each function is doing, what it returns to the user, and why it is doing it this way. Researchers can also use the project’s Github to point out bugs, ask for further clarification, and propose additions. {peacesciencer} takes seriously the Data Access and Research Transparency Initiative (DA-RT) initiative across all political science and endeavors for maximum transparency, leveraging open source and version control software to inform users of what data it uses and how it uses the data.

What is Included in {peacesciencer}

{peacesciencer} comes with a fully developed suite of built-in functions for generating some of the most widespread forms of peace science data and populating the data with important variables that recur in many quantitative analyses. The core functionality of {peacesciencer} reduces to two broad categories of functions. These categories are functions that create the base data of interest to a researcher and functions, called after the base data are created, that add variables of interest to the data frame or subset the base data to a handful of rows that the researcher deems appropriate for analysis.¹ Table 1 and Table 2 list these core functions as of version 1.0, the version of this package slated for release alongside the manuscript.²

Table 1 lists functions that create base data frames for a researcher starting an original project. They serve as functions that communicate the units of analysis supported in this package and that the package is capable of generating for an interested user. For example, create_stateyears() will generate the full universe of state-years from the Correlates of War (Correlates of War, 2011: v. 2016) or Gleditsch-Ward (Gleditsch & Ward, 1999: v. 2017) system, encompassing all state-years to the most recently concluded calendar year, depending on the arguments supplied to the user in the function. create_leaderyears() will generate the full universe of leader-years from the Archigos leader data (Goemans, Gleditsch & Chiozza, 2009: v. 4.1), optionally standardizing leader-years to the Gleditsch-Ward or Correlates of War state system data. As of version 1.0, {peacesciencer} is capable of creating full dyad-year data, leader-day data, leader-dyad-year data, leader-year data, state-day data, and state-year data.³ A vignette on the package’s website shows how users can create other forms of data from these functions as well (e.g. dyadic-dispute-year, leader-months, state-quarters).

Table 2 lists the main functions in {peacesciencer} that add information or subset the number of rows of the data to just those of interest to the user, describing these functions and listing whether they are applicable to dyad-year (D), leader-year (L), leader-dyad-year (LD), state-year (S) data or specialty functions applicable to just the dyadic conflict data (C).⁴ All these functions use raw or pre-processed data included in the package. For example, add_gml_mids() uses a dyadic dispute-year version of the MID data offered by Gibler et al. (2016: v. 2.2.1) and merges in information about whether there was an ongoing MID or MID onset in a dyad-year, leader-year, leader-dyad-year, or state-year. {peacesciencer} also has some data innovations included in these functions. For example, add_capital_distance() calculates distance between state capitals in kilometers using the Vincenty method (i.e. “as the crow flies”) based on an original data set of state capitals that accounts for instances when capitals moved (e.g. Brazil in 1960, Burundi in 2018). add_democracy() does more than just add Polity data to a data set. The data underpinning the function feature an innovation in democracy data, providing reasonable estimates of democracy using the Marquez (2016) method of extending the Unified Democracy Scores (UDS) data (Pemstein, Meserve & Melton, 2010) in addition to Polity estimates (Marshall, Gurr & Jaggers, 2017: v. 2017) and V-Dem estimates (Coppedge et al., 2020: v. 10).⁵

{peacesciencer}’s coverage focuses mostly on data that are released as standalone data sets for download, especially those in the Correlates of War or Gleditsch-Ward ecosystem of data. Data that can be obtained from a stable advanced programming interface—like the World Bank, for example—can be obtained through those other means (e.g. Arel-Bundock, 2021a). Its coverage will assuredly expand with new additions of interest to the peace science community, though the package already offers a lot to meet researcher needs.⁶

How to Install {peacesciencer}

{peacesciencer} is a package for the R programming language. This assumes at least some familiarity with the R programming language. Users should have at least version 3.5 of R, which should not be an issue since the most recent version—as of writing—is 4.1.3. {peacesciencer} is designed to be as user-friendly as possible. Those proficient in R, those just learning R, and those with no experience in R should be able to pick up its use fairly quickly.

{peacesciencer}’s functions work out of the box, though users should find their experience augmented by two additional downloads. First, RStudio offers an IDE that serves as a user-friendly graphical user interface (GUI) over what is, at its core, a programming language with a command-line interface. RStudio’s design will make it much easier for users to experiment with {peacesciencer}’s functionality and read its documentation to assist them with the use of these functions. The second additional download is {tidyverse}, itself a suite of packages that share a common form and design (Wickham et al., 2019). {peacesciencer} functions make considerable use of the component packages of {tidyverse}, and {peacesciencer} can work without it, but installing and loading {tidyverse} will allow the researcher to make quicker use of {peacesciencer}’s functionality. A user can open an R session by way of RStudio and install both packages as follows.⁷

# Install the packages for use
install.packages(c("tidyverse", "peacesciencer"))

R packages once installed need to be loaded with every R session (i.e. every time the user opens RStudio). The user can load both with the library() function in R.

# Load the packages for use
library(tidyverse)
library(peacesciencer)

Thereafter, a researcher can start using {peacesciencer} to create the kind of data they need.

A Tutorial on How to Use {peacesciencer}

I encourage users who are using {peacesciencer} for the first time, especially those who are learning R for the first time because of their interest in this package, to approach {peacesciencer} with an idea of the kind of data they want to create for the sake of a project. The core functionality of {peacesciencer} begins with the creation of a data frame, which can then be populated with various indicators of interest. No matter, the suggested use of {peacesciencer} begins with the creation of a data frame. To start, assume a new user without much familiarity with the R programming language installed RStudio, {tidyverse}, and {peacesciencer} with the idea of using {peacesciencer} to help them start a new research project that seeks to explain civil conflict onset across state-years. Toward that end, they have identified their unit of analysis is state-year and can be created with the create_stateyears(). To get started, I encourage entering the following command in the console in RStudio.

# See documentation for create_stateyears() function.
?create_stateyears()

This will open a documentation file for this function, which is itself quite verbose and informative for the user about what the function is doing. In this case, the documentation file will show there are three arguments in this function, each with built-in defaults. This function will allow the user to choose a state system for which they want state-years (system, which accepts either “cow” or “gw” for Correlates of War [CoW] state system data or Gleditsch-Ward [G-W] state system data and defaults to “cow”), whether they want to extend the state system to the most recently concluded calendar year (mry, which defaults to TRUE), and whether they may want to additionally subset the years to a more narrow temporal domain they may already have in mind (subset_years, which defaults to no subset of the data, returning all possible state-years). If the user simply ran the function with no overrides, the function would return all Correlates of War state-years from 1816 to the most recent year (2021, as of writing).

# Create all CoW state-years from 1816 to most recently concluded calendar year.
create_stateyears()
#> # A tibble: 16,926 × 3
#>    ccode statenme                  year
#>    <dbl> <chr>                    <int>
#>  1     2 United States of America  1816
#>  2     2 United States of America  1817
#>  3     2 United States of America  1818
#>  4     2 United States of America  1819
#>  5     2 United States of America  1820
#>  6     2 United States of America  1821
#>  7     2 United States of America  1822
#>  8     2 United States of America  1823
#>  9     2 United States of America  1824
#> 10     2 United States of America  1825
#> # … with 16,916 more rows

A user who approaches {peacesciencer} with a project in mind will see they can better tailor this function to what they want. Their interest in a state-year analysis of civil conflict will likely gravitate them toward the Gleditsch-Ward state system data, since that is the state system that serves as the basis of the Uppsala Conflict Data Program (UCDP) armed conflict data. They will also know they have no use for pre-1946 observations since civil conflict data typically have coverage only from 1946 forward. Thus, the user can supply some additional arguments to tailor the creation of data to just what they want (here: all Gleditsch-Ward state-years from 1946 to 2019).

# Create all G-W state years from 1946 to 2019.
create_stateyears(system = 'gw', subset_years = c(1946:2019))
#> # A tibble: 10,490 × 3
#>    gwcode statename                 year
#>     <dbl> <chr>                    <int>
#>  1      2 United States of America  1946
#>  2      2 United States of America  1947
#>  3      2 United States of America  1948
#>  4      2 United States of America  1949
#>  5      2 United States of America  1950
#>  6      2 United States of America  1951
#>  7      2 United States of America  1952
#>  8      2 United States of America  1953
#>  9      2 United States of America  1954
#> 10      2 United States of America  1955
#> # … with 10,480 more rows

Another reader may be interested in using {peacesciencer} for a research project using a leader-year unit of analysis. These data can be created with create_leaderyears(). Users can read more about what this function is doing by consulting the documentation file in R with the following command.

# See documentation for create_leaderyears() function.
?create_leaderyears()

This function has three arguments denoting the leader system to inform the creation of the leader-year data (i.e. Archigos) and two other arguments: standardize and subset_years. The standardize argument, which when it defaults to “none”, returns all leader-years as presented in the raw Archigos data. Archigos’ leader data are nominally denominated in the Gleditsch-Ward state system data, if not necessarily Gleditsch-Ward state system dates (e.g. Archigos often has leader entries prior to state system entry in a few cases). Thus, the user can standardize leader-year data to Gleditsch-Ward state system dates of CoW state system dates. Finally, the user can subset the leader-year data to a more narrow temporal domain that may interest them with the subset_years function. If a user is interested in creating a data set of leader-years for an analysis of inter-state conflict initiation with the GML MID data, they can create the data that interests them with the following function. Notice how create_leaderyears() also returns information about the leader too, like the leader’s approximate age that year, their gender, and information about their tenure.

# Create all leader-years for CoW states from 1870 to 2010.
create_leaderyears(standardize = "cow", subset_years = c(1870:2010))
#> # A tibble: 15,074 × 7
#>    obsid    ccode leader gender  year yrinoffice leaderage
#>    <chr>    <dbl> <chr>  <chr>  <dbl>      <dbl>     <dbl>
#>  1 USA-1869     2 Grant  M       1870          2        48
#>  2 USA-1869     2 Grant  M       1871          3        49
#>  3 USA-1869     2 Grant  M       1872          4        50
#>  4 USA-1869     2 Grant  M       1873          5        51
#>  5 USA-1869     2 Grant  M       1874          6        52
#>  6 USA-1869     2 Grant  M       1875          7        53
#>  7 USA-1869     2 Grant  M       1876          8        54
#>  8 USA-1869     2 Grant  M       1877          9        55
#>  9 USA-1877     2 Hayes  M       1877          1        55
#> 10 USA-1877     2 Hayes  M       1878          2        56
#> # … with 15,064 more rows

Researchers using {peacesciencer} to create data for their research project should start with one of these “create” functions. Whether state-year, dyad-year, or a leader-level analysis, these functions will create the full universe of cases of interest to a researcher.

# Create all non-directed dyad-years from 1816 to 2010.
create_dyadyears(directed = FALSE, subset_years = c(1816:2010))
#> # A tibble: 842,655 × 3
#>    ccode1 ccode2  year
#>     <dbl>  <dbl> <int>
#>  1      2     20  1920
#>  2      2     20  1921
#>  3      2     20  1922
#>  4      2     20  1923
#>  5      2     20  1924
#>  6      2     20  1925
#>  7      2     20  1926
#>  8      2     20  1927
#>  9      2     20  1928
#> 10      2     20  1929
#> # … with 842,645 more rows

# create base data, and pipe (%>%) to next function
create_dyadyears(directed = FALSE, subset_years = c(1816:2010)) %>%
  # subset data to politically relevant dyads (PRDs)
  filter_prd()
#> # A tibble: 112,282 × 7
#>    ccode1 ccode2  year conttype cowmaj1 cowmaj2   prd
#>     <dbl>  <dbl> <int>    <dbl>   <dbl>   <dbl> <dbl>
#>  1      2     20  1920        1       1       0     1
#>  2      2     20  1921        1       1       0     1
#>  3      2     20  1922        1       1       0     1
#>  4      2     20  1923        1       1       0     1
#>  5      2     20  1924        1       1       0     1
#>  6      2     20  1925        1       1       0     1
#>  7      2     20  1926        1       1       0     1
#>  8      2     20  1927        1       1       0     1
#>  9      2     20  1928        1       1       0     1
#> 10      2     20  1929        1       1       0     1
#> # … with 112,272 more rows

# create base data, and pipe (%>%) to next function
create_dyadyears(directed = FALSE, subset_years = c(1816:2010)) %>%
  # subset data to politically relevant dyads (PRDs), pipe to next function
  filter_prd() %>%
  # add conflict information from GML-MID data,
  add_gml_mids(keep = NULL) 
#> # A tibble: 112,282 × 9
#>    ccode1 ccode2  year conttype cowmaj1 cowmaj2   prd gmlmidonset gmlmidongoing
#>     <dbl>  <dbl> <dbl>    <dbl>   <dbl>   <dbl> <dbl>       <dbl>         <dbl>
#>  1      2     20  1920        1       1       0     1           0             0
#>  2      2     20  1921        1       1       0     1           0             0
#>  3      2     20  1922        1       1       0     1           0             0
#>  4      2     20  1923        1       1       0     1           0             0
#>  5      2     20  1924        1       1       0     1           0             0
#>  6      2     20  1925        1       1       0     1           0             0
#>  7      2     20  1926        1       1       0     1           0             0
#>  8      2     20  1927        1       1       0     1           0             0
#>  9      2     20  1928        1       1       0     1           0             0
#> 10      2     20  1929        1       1       0     1           0             0
#> # … with 112,272 more rows

# create base data, and pipe (%>%) to next function
create_dyadyears(directed = FALSE, subset_years = c(1816:2010)) %>%
  # subset data to politically relevant dyads (PRDs), pipe to next function
  filter_prd() %>%
  # add conflict information from GML-MID data, pipe to next function
  add_gml_mids(keep = NULL) %>%
  # add peace years ("spells")
  add_spells()
#> # A tibble: 112,282 × 10
#>    ccode1 ccode2  year conttype cowmaj1 cowmaj2   prd gmlmidonset gmlmidongoing
#>     <dbl>  <dbl> <dbl>    <dbl>   <dbl>   <dbl> <dbl>       <dbl>         <dbl>
#>  1      2     20  1920        1       1       0     1           0             0
#>  2      2     20  1921        1       1       0     1           0             0
#>  3      2     20  1922        1       1       0     1           0             0
#>  4      2     20  1923        1       1       0     1           0             0
#>  5      2     20  1924        1       1       0     1           0             0
#>  6      2     20  1925        1       1       0     1           0             0
#>  7      2     20  1926        1       1       0     1           0             0
#>  8      2     20  1927        1       1       0     1           0             0
#>  9      2     20  1928        1       1       0     1           0             0
#> 10      2     20  1929        1       1       0     1           0             0
#> # … with 112,272 more rows, and 1 more variable: gmlmidspell <dbl>

# create base data, and pipe (%>%) to next function
create_dyadyears(directed = FALSE, subset_years = c(1816:2010)) %>%
  # subset data to politically relevant dyads (PRDs), pipe to next function
  filter_prd() %>%
  # add conflict information from GML-MID data, pipe to next function
  add_gml_mids(keep = NULL) %>%
  # add peace years ("spells"), pipe to next function
  add_spells() %>%
  # add capabilities data, pipe to next function
  add_nmc() %>%
  # add some estimates about democracy for each state, pipe to next function
  add_democracy() %>%
  # add information about alliance commitments in dyad-year
  add_cow_alliance() %>%
  # finish with information about population and GDP/SDP
  # and then assign to object, called, minimally, 'Data'
  add_sdp_gdp() -> Data

Data
#> # A tibble: 112,282 × 42
#>    ccode1 ccode2  year conttype cowmaj1 cowmaj2   prd gmlmidonset gmlmidongoing
#>     <dbl>  <dbl> <dbl>    <dbl>   <dbl>   <dbl> <dbl>       <dbl>         <dbl>
#>  1      2     20  1920        1       1       0     1           0             0
#>  2      2     20  1921        1       1       0     1           0             0
#>  3      2     20  1922        1       1       0     1           0             0
#>  4      2     20  1923        1       1       0     1           0             0
#>  5      2     20  1924        1       1       0     1           0             0
#>  6      2     20  1925        1       1       0     1           0             0
#>  7      2     20  1926        1       1       0     1           0             0
#>  8      2     20  1927        1       1       0     1           0             0
#>  9      2     20  1928        1       1       0     1           0             0
#> 10      2     20  1929        1       1       0     1           0             0
#> # … with 112,272 more rows, and 33 more variables: gmlmidspell <dbl>,
#> #   milex1 <dbl>, milper1 <dbl>, irst1 <dbl>, pec1 <dbl>, tpop1 <dbl>,
#> #   upop1 <dbl>, cinc1 <dbl>, milex2 <dbl>, milper2 <dbl>, irst2 <dbl>,
#> #   pec2 <dbl>, tpop2 <dbl>, upop2 <dbl>, cinc2 <dbl>, v2x_polyarchy1 <dbl>,
#> #   polity21 <dbl>, xm_qudsest1 <dbl>, v2x_polyarchy2 <dbl>, polity22 <dbl>,
#> #   xm_qudsest2 <dbl>, cow_defense <dbl>, cow_neutral <dbl>, cow_nonagg <dbl>,
#> #   cow_entente <dbl>, wbgdp2011est1 <dbl>, wbpopest1 <dbl>, sdpest1 <dbl>, …

# Create a set of state-year data for a civil conflict analysis.
create_stateyears(system = 'gw', subset_years = c(1946:2019)) %>%
  add_ucdp_acd(type="intrastate", only_wars = FALSE) %>%
  add_spells() %>%
  add_democracy() %>%
  add_creg_fractionalization() %>%
  add_sdp_gdp() %>%
  add_rugged_terrain() -> Data

# Repeat the process, but for a new DV of just wars
create_stateyears(system = 'gw', subset_years = c(1946:2019)) %>%
  add_ucdp_acd(type="intrastate", only_wars = TRUE) %>%
  add_spells() %>%
  rename_at(vars(ucdpongoing:ucdpspell), ~paste0("war_", .)) %>%
  left_join(Data, .) -> Data

# Create a set of leader-year data for an analysis of conflict initiation.
create_leaderyears(standardize = "cow", subset_years=c(1875:2010)) %>%
  add_gml_mids() %>%
  add_spells() %>%
  add_lead() %>%
  add_nmc() %>%
  add_democracy() -> Data

A Comparison with Other Approaches

{peacesciencer} is not the only software available to peace science researchers who want to reduce the time and energy required to faithfully recreate data from scratch. Alternatives exist, some more inaccessible than others. NewGene, for example, is a stand-alone software program for Microsoft Windows and Mac that can create various types of data of interest to international relations scholars (Bennett, Poast & Stam, 2019). NewGene is itself the evolution of EUGene, which served conflict researchers well for over a decade (Bennett & Stam, 2000). Finally, peace scientists well-versed in Structured Query Language (SQL) could use one of several “join” transformations to create dyad-year data from state system data, even if this might amount to a detour in the peace scientist’s research agenda for this particular task.¹² A comparison of {peacesciencer} with EUGene and NewGene suggests the following benefits of the package while emphasizing areas where other options may have some advantages.

EUGene is the clear inspiration for this package. Though its original impetus was the generation of expected utility data for evaluating Bueno de Mesquita & Lalman (1992) (i.e. the “EU” in “EUGene”), the software became quite popular for peace science scholars in the early 2000s for helping them start new projects from scratch with important data already provided. {peacesciencer} covers all the same units of analysis that EUGene covers, as of version 3.2.¹³ EUGene has more explicit support for dyadic dispute-year data whereas {peacesciencer} treats dyadic dispute-year data as a derivation of dyad-year data, with respect to functions that populate base data with additional information.¹⁴ {peacesciencer} may reflect more current research interests in the peace science community. This is why there are leader-level data and support for the G-W (and UCDP) ecosystem of data that EUGene does not have, but there is no function yet for things like calculating expected utility values. Importantly, though, {peacesciencer} mimics the verbosity of EUGene’s user manual. EUGene’s user manual was amply informative about what it was calculating and why it was doing what it was doing for some defaults. Likewise, {peacesciencer}’s documentation strives to be as informative as possible as to what it is doing and why it is doing what it is doing for some defaults. A scholar who remembers EUGene well will ideally think of {peacesciencer} as the most faithful approximation of what that software did for the community at the time. It has the added benefit of being agnostic to the researcher’s operating system, having greater flexibility of data types supported, and better reflecting more current frontiers in the community. It does have the drawback of requiring at least some level of comfort with the R programming language.

NewGene is the latest evolution of EUGene, at least as a stand-alone executable program for creating the kind of data of interest to the peace science community. NewGene’s greatest strength, relative to EUGene and even {peacesciencer}, is its support for k-adic data (c.f. Poast, 2010). k-adic levels of analysis are not yet supported in {peacesciencer} and users interested in generating k-adic data should consider downloading NewGene. No matter, {peacesciencer} has several superlatives in relation to NewGene. It supports leader-year and leader-dyad-year data while NewGene does not. It offers support for the G-W (and UCDP) ecosystem of data whereas NewGene does not and is mostly aimed for researchers interested in inter-state conflict. NewGene deviates a bit from EUGene by only indirectly asking users what kind of data they want (e.g. state-year, dyad-year) and without providing too much detail about what it is doing and why it is doing what it is doing. For example, NewGene only indirectly states the unit of analysis of the data to be generated near the top of its interface by asking the user how many country columns they want. This is an indirect way of the user to get data that are state-year, dyad-year, triad-year (etc.), which are then expanded and populated with data at various levels. {peacesciencer}, much like EUGene, is more explicit, encouraging the user to be upfront about what their unit of analysis is and what are the data that can be plausibly plugged into the data the user is creating. {peacesciencer}, again, does expect at least some level of comfort with the R programming language, but even this comes with greater ease of interpreting what is the unit of analysis and what are the primary spatial and temporal units that serve as the basis of the data.

Conclusion

{peacesciencer} is already more than capable of creating the kind of data in high demand in peace science. It can create dyad-year, leader-year, leader-dyad-year, and state-year data (among others). It is also generalizable to the dispute data included in the package, allowing for merging into dispute-year data as well. This feature showed how it can effectively approximate three types of analyses in wide use in the peace science community. Surely researchers can and will add more information to these simple analyses after using {peacesciencer}, but the package already does a lot of the tedious work for researchers. It also does this in a maximally transparent way that conforms well to the DA-RT initiative across all political science. This is not to say {peacesciencer} does everything, but {peacesciencer} can only evolve and expand on what it already does well. This package can only evolve to meet new analytical demands for the peace science community. Users are free to request new features as “issues” on the project’s Github.

Finally, a skeptical reader should not think that making the process as simple as possible necessarily facilitates poor decision-making by the user. In cases where it is evident what the user wants (e.g. an estimate of the level of democracy in the state-year), {peacesciencer} does the necessary work to provide the user that information. However, the package makes sure to leave important decision-making to the researcher. For example, add_cow_alliance() returns information about various types of alliance pledges in the dyad-year—should one exist—but leaves it to the researcher to say whether they want to define the presence of an alliance to be just a defense pledge or any type of alliance pledge. add_contiguity() returns information about the type of contiguity relationship in the dyad-year, but leaves it to the researcher whether they want to code a contiguity variable as the presence of a mutual land border or some other type of contiguity relationship. The documentation included in this package, and on the website, is replete with caveats about the underlying data (e.g. the contiguity data are not ordinal and should not be treated as such), how and where data issues arise (e.g. how CoW state system data differ from Gleditsch-Ward data and how one is coerced into the other), and how researchers should consider optimally using its functionality (e.g. add_ucdp_acd() probably should not lump all forms of conflict together (c.f. Gibler & Miller, Forthcoming)). {peacesciencer} does not endeavor to make researchers lazy or sloppy, and it does not ultimately do this. Instead, {peacesciencer} encourages well-reasoned design decisions by the user up front and reduces the tedium associated with starting quantitative peace science research. It achieves this in a quick, robust, and transparent way.

References