Unraveling complex biology with biological knowledge graphs. Content licensed under CC BY 4.0.

Charles Tapley Hoyt

I’m working through making a contribution to pandoc that adds first-class support for author role annotations using the Contribution Role Taxonomy (CRediT) and also outputs compliant Journal Publishing Tag Set (JATS) XML. This has lead me down a (losing) journey with learning the Haskell programming language, so I thought I would post a short note on a function I tried to understand.

Some Haskell I Tried to Write

I’ve just returned from the 17

 th

Annual International Biocuration Conference at the Indian Biological Data Centre (IBDC) in Faridabad, India.

Discussions and Follow-ups from Biocuration 2024

Using Pydantic for encoding data models and FastAPI for implementing APIs on top of them has become a staple for many Python programmers.

Semantic Pydantic

I finally got back into reading! Over winter break 2022, I started the Stormlight Archive then followed up in 2023 by reading the entirety of Brandon Sanderson’s

 Cosmere

, as well as a some other fantasy, science fiction, and literary fiction. Here’s the list.

Books I Read in 2023

The Unified Medical Language System (UMLS) is a widely used biomedical and clinical vocabulary maintained by the United States National Library of Medicine. However, it is notoriously difficult to access and work with due to licensing restrictions and its complex download system. In the same vein as my previous posts about DrugBank and ChEMBL, this post describes open source software I’ve developed for downloading and working with this data.

Unlocking UMLS

Today’s short post is about three SPARQL queries I wrote to get bibliometric information about journals and publishers out of Wikidata. Each of the following queries can be readily copy-pasted into the Wikidata Query Service and run in the browser.

Querying Journals and Publishers in Wikidata

I was recently nominated for the International Society for Biocuration’s Excellence in Biocuration Early Career Award (results will be announced on June 14

 th

!). This made me curious about how to model nominations and awards on Wikidata. In this post, I’ll describe how to curate awards, nominations, recipients, and how to make SPARQL queries to get them.

Modeling and Querying Awards in Wikidata

Archival Resource Keys (ARKs) are flavor of persistent identifiers like DOIs, URNs, and Handles that have the benefit of being free, flexible with what metadata gets attached, and natively able to resolve to web pages. Name-to-Thing (N2T) implements a resolver for a variety of ARKs, so this blog post is about how that resolver can be re-implemented with the curies Python package. In a lot of ways, ARKs look and act like CURIEs.

Re-implementing the N2T ARK Resolver

I’ve been working on improving reproducibility in the field of cheminformatics for some time now. For example, I’ve written posts about making data from DrugBank and ChEMBL more actionable. Over the last year, I’ve been preparing a concept with the editors of the Journal of Cheminformatics on how to include an assessment of reproducibility to reviews of manuscripts submitted to the journal.

Reproducibility Pilot in the Journal of Cheminformatics

Several controlled vocabularies and ontologies that aren’t themselves OBO Foundry ontologies use unsanctioned OBO PURLs. This post is about how to use the Bioregistry to identify which resources are doing this and to give some insight into how we arrived in this situation. Background on the OBO Foundry   The OBO Foundry is a set of independent, interoperable biomedical ontologies that aspire to using shared development principles.

Resources masquerading as OBO Foundry ontologies

This blog is normally about

 very serious science

, but I’m taking a break from that for the evening to advertize my band’s upcoming show on April 8

 th

in the SPH Music Masters Finale (aka, the German Battle of the Bands). We need your support!

The Representatives of Monkey Jack - German Battle of the Bands Finale

The Open Researcher and Contributor Identifier (ORCID) database is an invaluable resource that supports the unambiguous identification of researchers. However, its first party data dump is too complex, verbose, and unstandardized for many use cases. This post describes open source software I wrote that automates downloading, processing, and exporting ORCID into a more usable form. I put the results on Zenodo under the CC0 license.

Easier ORCID

The International Society of Biocuration (ISB) partners with the journal Database to get discounts for its members when they publish there. This means the ISB’s executive committee needs to send a member list to the journal’s editor.

Programmatic Access to a Wordpress User List

Biopragmatics

I'm working through making a contribution to
[pandoc](https://github.com/jgm/pandoc) that adds first-class support
for author role annotations using the [Contribution Role Taxonomy
(CRediT)](https://credit.niso.org/contributor-roles) and also outputs
compliant [Journal Publishing Tag Set
(JATS)](https://jats.nlm.nih.gov/publishing/) XML. This has lead me down
a (losing) journey with learning the Haskell programming language, so I
thought I would post a short note on a function I tried to understand.

For some context, the first stream of changes I sent were in [jgm/pandoc
\#10153](https://github.com/jgm/pandoc/pull/10153). I have done some
in-place squashes on the git history, so apologies to future readers if
this isn't a helpful thread. I appreciated the help from Pandoc's
maintainer John MacFarlane, but he suggested I add the following code
and I just don't know enough Haskell to make sense of it:

:::: {.language-haskell .highlighter-rouge}
::: {.highlight}
``` highlight
addCreditName :: M.Map Text Text -> M.Map Text Text
addCreditName rolemap =
  case M.lookup "credit-name" rolemap of
    Just _ -> rolemap
    Nothing -> maybe id (M.insert "credit-name")
      (M.lookup "credit-id" rolemap >>= flip M.lookup creditNames)
```
:::
::::

The goal was actually pretty simple. I have a dictionary that maybe has
a `credit-name`{.language-plaintext .highlighter-rouge} key. If it does,
then we're done. If not, and it has a `credit-id`{.language-plaintext
.highlighter-rouge} key, get the value out of that and look up the
`credit-name`{.language-plaintext .highlighter-rouge} using an external
`creditNames`{.language-plaintext .highlighter-rouge} dictionary. The
problem is, I can't understand this without going on a massive deep-dive
on Haskell to actually understand the way Haskell programs treat
function calls, monads (which is a yo-dawg in the category of jokes),
and function polymorphisms.

One thing to keep in mind is that Haskell is a functional programming
language and everything is supposed to be immutable. This means that
mapping insertion operations (`M.insert`{.language-plaintext
.highlighter-rouge}) are returning a new dictionary. That made it
possible to at least try a more verbose way of doing what I needed to.

I like Haskell's `case`{.language-plaintext .highlighter-rouge}
statement and first-class notion of optionals, so I thought I'd try
re-writing this code from above in a bit more straight-forward way:

:::: {.language-haskell .highlighter-rouge}
::: {.highlight}
``` highlight
addCreditName :: M.Map Text Text -> M.Map Text Text
addCreditName role =
  -- Try looking if there's a "credit-name" key in the role dictionary
  case M.lookup "credit-name" role of
    -- If there's already an explicitly specified "credit-name"
    -- key in the role dictionary, then we don't have to do anything
    Just _ -> role
    Nothing ->
      case M.lookup "credit-id" role of
        -- If there isn't already a "credit-id" key in the role
        -- dictionary, then we aren't able to do anything
        Nothing -> role
        Just creditIdentifier ->
          -- Try looking up the value from the "credit-id" key, which
          -- we stored in the `creditIdentifier` variable, is in the
          -- creditNames dictionary, which is defined as a constant above
          case M.lookup creditIdentifier creditNames of
            -- If the credit-id value from the role dictionary is not
            -- in the creditNames lookup dictionary, then we can't do anything
            Nothing -> role
            -- If the credit-id value from the role dictionary is in
            -- the creditNames lookup dictionary, insert it back into the
            -- role dictionary under the "credit-name" key and return
            Just creditName -> M.insert "credit-name" creditName role
```
:::
::::

The funny thing is, I have been called out before on increasing
confusion by getting tricky when writing Python code. I guess I had it
coming!
