Editors

This page includes:

• An Editor Overview of the current status of all members of the editorial team
• An Editor Reviews table, providing details of all reviews handled by each editor
• Two graphs of recent Editorial Load which can be used to help assign editors in a way that best distributes the load throughout the entire team.

Warning in editor_vacation_status(airtable_base_id): Not all airtable editor
names match slack names. GitHub handles of mis-matches: ldecicco-usgs

Editor-in-Charge

Current Editor-in-Charge is Adam Sparks.

Next Editor-in-Charge (from 2024-11-01) will be Emily Riederer.

Editor Overview

The following interactive table summarises the availability of our editorial team. This information is intended to help identify editors who may be available to handle new submissions to rOpenSci’s software peer-review system. The choice of editors should also be made in a way that best distributes the recent editorial loads depicted in the Past Editorial Load section.

Values are sorted by the periods of time since editors were last active in peer review threads (the “Last Active” column), sorted in decreasing order so the first listed editors are those who have been inactive for the longest time. Values in this ‘Last Active’ column are also hyperlinked to the most recent submission issue for each editor. The table can be filtered with the two check-box selectors:

• Stats to filter by statistical software submission (true), general submission (false), or both.
• Editor Status to filter by the current status of editors. Editors are “FREE” is they are not currently handling any submissions, and are highlighted in yellow.

// This adds a 'rowColor' variable to the editor data
editorData = {
    return transpose(ed_status_in).map(row => ({
        ...row,
        rowColor: row.status === "FREE" ? "yellow" : "transparent",
    }));
}

viewof stats = Inputs.checkbox(
    [true, false],
    { value: [false], 
        label: "Stats:"
    }
)
viewof status = Inputs.checkbox(
    ["FREE", "BUSY", "ON LEAVE"], 
    { value: ["FREE"], 
        label: "Editor Status:"
    }
)

filtered = editorData.filter(function(editor) {
  return status.includes(editor.status) &&
         stats.includes(editor.stats);
})

sortColumn = "inactive_days"

// This sorts in reverse order:
filteredSorted = filtered.sort((a, b) => {
  if (a[sortColumn] < b[sortColumn]) {
    return 1;
  }
  if (a[sortColumn] > b[sortColumn]) {
    return -1;
  }
  return 0;
});

// Definition of colorTable function, adapted from
// https://observablehq.com/@mootari/colored-table-rows
// This can't be placed in a separate file, because that requires importing
// observable/table, but there is no path here to do that import.
function colorTable(data, {
        colorColumn,
        colorOpacity = 0.5,
        editorColumn,
        lastActiveColumn,
        issueNumColumn,
        columns = undefined,
        format = {}, ...options}) {
  const [row] = data;
  if(!row) return Inputs.table(data, options);
  
  let index = Object.keys(row).indexOf(colorColumn);
  if(index < 0) throw Error("colorColumn not found in data");
  if(format[colorColumn]) throw Error("colorColumn is reserved");
  if(columns && columns.indexOf(colorColumn) < 0) columns.push(colorColumn);
  if(columns) index = columns.indexOf(colorColumn);
  const nth = `nth-child(${index + 2})`;

  // Observable Table doesn't know about rows, so need to convert the
  // "lastActiveColumn" into an array with the issue number and last active
  // string so then pass to the `format` call below to construct <a> href
  // objects:
  const preprocessedData = data.map(row => ({
     ...row,
     [lastActiveColumn]: [row[issueNumColumn],row[lastActiveColumn]]
  }));``

  const form = Inputs.table(preprocessedData, {
    format: {
      ...format,
      [colorColumn]: d => htl.html`<div style="--row-color:${d}">`,
      [editorColumn]: d => htl.html`<a href="https://github.com/${d}">${d}</a>`,
      [lastActiveColumn]: d => htl.html`<a href="https://github.com/ropensci/software-review/issues/${d[0]}">${d[1]}</a>`,
    },
    columns,
    ...options
  });

  const scope = DOM.uid().id;
  form.classList.add(scope);
  
  form.append(htl.html`<style>

    /* Ensure that the sticky header always stays on top */
    .${scope} thead { position: relative; z-index: 2 }

    /* Hide the last column */
    .${scope} th:${nth},
    .${scope} td:${nth} { width: 0; padding: 0 }
    .${scope} th:${nth} { visibility: hidden }

    /* Inject the background color */
    .${scope} tr { position: relative }
    .${scope} td:${nth} div:after {
      opacity: ${colorOpacity};
      content: "";
      display: block;
      height: 100%;
      width: 100%;
      position: absolute;
      left: 0;
      top: 0;
      z-index: -1;
      background-color: var(--row-color);
    }
  `);

  return form;
}

// And modified verison for open reviews table
function reviewTable(data, {
        colorColumn,
        colorOpacity = 0.5,
        issueNumColumn,
        titleColumn,
        columns = undefined,
        format = {}, ...options}) {
  const [row] = data;
  if(!row) return Inputs.table(data, options);
  
  let index = Object.keys(row).indexOf(colorColumn);
  if(index < 0) throw Error("colorColumn not found in data");
  if(format[colorColumn]) throw Error("colorColumn is reserved");
  if(columns && columns.indexOf(colorColumn) < 0) columns.push(colorColumn);
  if(columns) index = columns.indexOf(colorColumn);
  const nth = `nth-child(${index + 2})`;

  // Observable Table doesn't know about rows, so need to convert the
  // "titleColumn" into an array with the title and issue number
  // so then pass to the `format` call below to construct <a> href
  // objects:
  const preprocessedData = data.map(row => ({
     ...row,
     [titleColumn]: [row[titleColumn],row[issueNumColumn]]
  }));``

  const form = Inputs.table(preprocessedData, {
    format: {
      ...format,
      [colorColumn]: d => htl.html`<div style="--row-color:${d}">`,
      [issueNumColumn]: d => htl.html`<a href="https://github.com/ropensci/software-review/issues/${d}">${d}</a>`,
      [titleColumn]: d => htl.html`<span style="white-space:break-spaces;"><a href="https://github.com/ropensci/software-review/issues/${d[1]}">${d[0]}</a></span>`,
    },
    columns,
    ...options
  });

  const scope = DOM.uid().id;
  form.classList.add(scope);
  
  form.append(htl.html`<style>

    /* Ensure that the sticky header always stays on top */
    .${scope} thead { position: relative; z-index: 2 }

    /* Hide the last column */
    .${scope} th:${nth},
    .${scope} td:${nth} { width: 0; padding: 0 }
    .${scope} th:${nth} { visibility: hidden }

    /* Inject the background color */
    .${scope} tr { position: relative }
    .${scope} td:${nth} div:after {
      opacity: ${colorOpacity};
      content: "";
      display: block;
      height: 100%;
      width: 100%;
      position: absolute;
      left: 0;
      top: 0;
      z-index: -1;
      background-color: var(--row-color);
    }
  `);

  return form;
}

columns = ["editor", "last_active", "status", "stats", "Languages", "Expertise"]
colorTable(filteredSorted,
  {
    colorColumn: "rowColor",
    editorColumn: "editor",
    lastActiveColumn: "last_active",
    issueNumColumn: "number",
    columns: columns,
    height: 'auto',
    header: {
      "editor": "Editor",
      "last_active": "Last Active",
      "status": "Status",
      "stats": "Stats",
    },
    format: {
      "Expertise": d => htl.html`<span style="white-space:break-spaces;">${d}</span>`,
    },
  }
)

Editor Reviews

This panel provides data on reviews handled by each editor. Data are shown for current editors only, with reviews listed from most to least recent. Open reviews are highlighted in yellow.

edReviewsIn = transpose(ed_reviews_in)
// Get array of unique eds for input selector:
editorsAll = edReviewsIn.map(function(item) {
    return item.editor;
});
editors = Array.from(new Set(editorsAll));

// Add 'rowColor' variable:
edReviews = {
    return edReviewsIn.map(row => ({
        ...row,
        rowColor: row.state === "OPEN" ? "yellow" : "transparent",
    }));
}

viewof editor = Inputs.select(editors, {multiple: false, label: "Editor:"})
viewof state = Inputs.checkbox(
    ["OPEN", "CLOSED"],
    { value: ["OPEN"], label: "Issue State:" }
)

filteredRevs = edReviews.filter(function(ed) {
  return editor.includes(ed.editor) && state.includes(ed.state)
})

sortColumnRevs = "number"

// This sorts in reverse order:
filteredSortedRevs = filteredRevs.sort((a, b) => {
  if (a[sortColumnRevs] < b[sortColumnRevs]) {
    return 1;
  }
  if (a[sortColumnRevs] > b[sortColumnRevs]) {
    return -1;
  }
  return 0;
});

numberColumn = "number"
columnsRevs = ["number", "title", "state", "opened_at", "closed_at"]

colorTable(filteredSortedRevs,
  {
    colorColumn: "rowColor",
    editorColumn: "editor",
    issueNumColumn: "number",
    columns: columnsRevs,
    format: {
      [numberColumn]: d => htl.html`<a href="https://github.com/ropensci/software-review/issues/${d}">${d}</a>`,
      "title": d => htl.html`<span style="white-space:break-spaces;">${d}</span>`,
    },
    header: {
      "number": "Issue number",
      "title": "Title",
      "state": "State",
      "opened_at": "Opened",
      "closed_at": "Closed",
    },
    height: 'auto',
  }
)

Editorial Load

The following sections summarise the recent workload of our editorial team. We aim to distribute our workload as evenly as possible across the editorial team. Editors for new submissions should accordingly be chosen from those who have had relatively low recent workloads. All of the following data and graphs exclude any editors who are currently on leave.

Individual Editor Load: New Submissions

This first graph shows the number of new submissions per quarter taken on by each editor. We aim to allocate no more than one new submission to each editor per quarter, or a maximum of four per year. Each block in this graph represents a quarter-year, so values should not exceed one. Editors for incoming reviews should preferably be chosen from those who have not handled any submissions in the present or preceding quarters.

Individual Editor Load: Concurrent Reviews

The following graph shows numbers of concurrent reviews handled by editors over the preceding 2 years. We aim to distribute workloads across editors as evenly as possible, and this graph should be used in addition to the above graph to aid that task. Note that we have no specific upper limits on numbers of concurrent reviews, and reviews may extend over long time periods with very little editorial intervention. Nevertheless, low numbers of concurrent reviews may be interpreted to reflect relatively low editorial workload.