As historic "core devs" move on, where do we go from here?

[I emailed this to some people a month ago, but it’s better as a Talk post, so I’m copy-pasting.]

An ill-formed thought that I wanted to get written down while it’s still fresh:

Years ago when something was a “core OpenMRS priority that needs to be addressed now”, then we could assign some concrete people to work on it. (And we could count on >3.5 FTEs across me, Wyclif, Daniel, and Rafal. Maybe more when Rafal had a dedicated SolDevelo team.)

As of next month we’ll have <1.5 FTEs to reliably call on (I don’t know exactly how Wyclif and Daniel’s time is allocated). The Andela interns are an exciting new development, but they primarily do front-end JavaScript, not back-end Java code, so that’s pretty limiting.

Further, our core tech team of folks who consistently join design calls, and try to coordinate our technical direction, is also shrinking. The typical group is Burke, Wyclif, Daniel, and I.

And the alarming thing is that these are all “old folks”, and I’m not aware of a pipeline to get more people in the mix.

I’ve spent quite a few hours this week trying to find someone to test out the Sync 2 work that SolDevelo has done, and my impression is that there are lot of things being blocked by blockers that are actually quite small, but just aren’t the priority of any particular implementation. (And I think this pattern is repeated all over.) So I’m wanting to call on “core devs” to do things, but I feel like our ability to do that is small and dwindling.

I can think of several responses, and I think we should pursue several in parallel.

  1. Get more core devs in the same old way (I don’t know if there’s a plan to replace Rafal at RI with someone who would have any time allocated to OpenMRS or not.)

  2. Explicitly make someone the full-time “Lead Community Dev”. Presumably this is a paid position and should be included in our Digital Square ask. (I’m thinking something a bit analogous to Lars for DHIS2.)

  3. Try out the idea of a rotating “OpenMRS Fellowship”: someone who gets stipend-level pay, to spend 6 months working on OpenMRS community-priority work. Could be funded out of Pineapple, and maybe we can find some matching funds and/or people in Nairobi, Kampala, etc, to donate office space. I will propose this once there’s a mechanism for proposing projects to do with Pineapple funding.

  4. Improve communication/coordination with active community developers to try to get them more interested in community-prioritized tickets. (I guess this is mainly not all the old /dev/5s but there are newer folks who could do more. I don’t know who they are though, or how best to engage. E.g. it would be nice to analyze whether there are people who are active on IRC/telegram and who are also making a lot of commits.)

  5. …on top of that, get people (or their employers) to commit that they can do X hours per month of community-prioritized work, and try to organize around this.

  6. Get a technical PM, who can find inventive ways to get partner orgs to do this community-prioritized work (either by realizing it’s on their roadmap anyway, or horse-trading “if you do X I can get this other org to do Y, which you need”).

Anyway, I’m going to click Send now so that I can go back to working on [something that was relevant a month ago]…


Useful organization of responses.

I think #2 (explicit staff role) would be funded out of Digital Square and Pineapple, as would #3 (supported, rotating Fellows). #2 is needed to direct #3, provide a reliable “guide” for #4 and accomplish some of #6. So, I think a #2 with both technical and people skills, and time to spend on both of these.

I think #5 is a hard sell, but one always worth trying for. Perhaps discussion with eSaude, PIH, others, could clarify the value points here - but it’s likely to be explicit shared value, which makes it start to sound more like #4, with someone in the center who knows who needs what, and who can work together on it.

#1 would be ideal - but only because it’s so easy…!

@darius Thank you starting this thread, I have been thinking about the same thing for UgandaEMR for long term sustainability, so my ideas are do them all (then see what sticks in different environments):

  1. Find a full time paid community dev - necessary to keep up the momentum
  2. Find funding for OpenMRS Fellowships - which are rotatable which help grow “developers” into other jobs
  3. Work with distributions to help drive contributions back into OpenMRS - this will help develop “OpenMRS” dev capacity world wide and also to feed the giants on whose shoulders
  4. Find funding to have OpenMRS “developer” bootcamps under some of the partner organizations can support to build local capacity - In METS we have tried to do this This can actually also form the first 1-2 days of Implementor conferences (Monday/Tuesday) later

Funding options:

  • During the conference we talked about a HIV/TB module so this could be funded through disease specific funding agencies WHO, GATES, CHAI, UN agencies etc, providing actual work that can be done by fellows
  • Work through partnerships with communities/implementing partners and funding mechanisms such METS, PIH, eSaude and others
  • Sell to governments & state universities to leverage programs in public health, epidemiology, and health informatics to leverage OpenMRS

Iam personally interested in becoming a core Dev, but there is still a great valley between my current expertise and my target, so like @ssmusoke and @lober indicated there needs to be funding for fellowships and partner with IP’s and Governments to organise lengthy(month-long ) boot camps to curve new Devs for backend / Core OpenMRS.

I personally attended the UgandaEMR boot camp last year organised by METS ,and it was a terrific experience designing Uganda MOH specific HMIS forms , but it was short (1 week) , this could be taken as a prototype for Core as well,prioitising Java Devs.

1 Like

And about testing sync is there anything i can do?I had not noticed this.

I think it’s worth pointing out that “core dev” does not mean the same thing as “experienced dev” (although of course for someone like Rafal it means both).

A “core dev” means someone who can work on “core OpenMRS priorities,” and the only thing it takes to do this is time and desire.

For example we plan to soon have a sprint to help people upgrade to later version of OpenMRS (see Proposing a sprint to help people upgrade to Platform 2.x (Mozambique tried to upgrade to Platform 2.x, but was blocked for various reasons)) As part of this I think we will need someone to upgrade the dataentrystatistics module so that it can support Platform 2.x. But someone actually needs to do this work, and so far people that have been connected to implementations have not considered it a priority. So anyone who wants to be a “core dev” can take this task up and work on it.

More generally, during our project management calls on Mondays, it would often come up “ah, someone needs to work on x, because this is a blocker for some project we’re tracking”, but we don’t have a way to say "if we add this to the list of ‘this month’s priorities’ then we can expect someone to pick it up and get it finished in the next month.

In a simplistic view, I’d say “we can’t do this because we haven’t hired enough core devs” but really the answer should be “in the OpenMRS community there are many people who could do this; one of them has time this months; we just need to communicate better”.

The thread is here: Sync 2.0 MVP testing. But it’s about finding an implementation to do the testing, not (yet) looking for individuals to test things out.

1 Like

@darius thanks alot for the info , am willing to offer some time to work on that(working on upgrading dataentrystatistics module) ,as well so can you curate that, so that we may get going?

oops it also looks like the dataentrystatitistics-module Documentation is too summarised , may be it’s my own observer opinion.

@darius do you mean an implementation like UgandaEMR ?

Hey @darius this has just spark my interest. Specifically being a core Dev.

But just to get me in the loop, do you mind clarifying what “core OpenMRS priorities” Are?

Is there maybe confusion about the word “core” in this? Are you referring to those devs who work on the platform as a core component, or do core devs work on other things as well? Is this different then those that work on RefApp or modules?

@janflowers the word core in ‘core dev’ really implies nothing, a core dev is someone that prioritizes their day to day tasks primarily towards OpenMRS development in general.


@wyclif ok,thanks and nothing like “Platform Specific Committer” syn with “TRUNK” ?

@darius One more addition to a way of building more devs focused on OpenMRS core code tasks and needs, would be to have opportunities for getting embedded within implementations - so as to help drive platform features that support specific implementations.

OR vice versa, where by implementors spend some time focusing on OpenMRS core features to support their needs, a hard sell almost like refactoring

@tendomart Great to hear this, and we’re happy to have your contribution! Tendo, you already know that we’re discussing this on the other thread here (at message 28-29): Proposing a sprint to help people upgrade to Platform 2.x (Mozambique tried to upgrade to Platform 2.x, but was blocked for various reasons)

For example, yes. I mean someone who has one or more installations of OpenMRS, that are running older versions of the platform, and want to upgrade.

@samuel34 it’s a good question. The quick answer is easy: “core OpenMRS priorities” means things that are important to the OpenMRS community as a whole, and not just to one particular implementation or developer.

As to how exactly we define those, that’s harder! Right now, two things happen:

  1. sometimes community-focused devs like @dkayiwa, @wyclif, or I will mark a particular JIRA ticket as “community-priority”. (See the open ones here.)
  2. on the Monday project management calls we sometimes notice that something is intrinsically important, or it’s a blocker so that other things can move forwards. (That’s where this recent example of “multiple groups have been unable to upgrade to platform 2.x, and this is a general problem for OpenMRS since it means that many orgs can’t take advantage of new development like Sync 2.0; therefore it’s a priority to help people get upgraded”.)

There are no objective criteria in either case, it’s really just a judgment call made by some people. But anyone is technically allowed to use the “community-priority” label on JIRA, or to join the Monday PM calls, or to just post here saying “I think X is important and we should organize efforts around it.”

True, it’s a bit inconvenient that we’ve used the phrase “core dev”, and also we have a piece of code called “openmrs core”, and core means different things in both cases.

As Wyclif replied, if you’re doing work that carries the OpenMRS platform forward because it’s useful/important to many groups, and not just your employer, or yourself, then you’re acting as a “core dev.”

(E.g. if you add a REST API to an existing module because your implementation needs it, that’s not really acting as a core dev; but if you do the exact same thing because “the community” said it’s important to be adding REST APIs to commonly-used modules, then you are acting as one.)

We should probably stop using the phrase “core dev” entirely. Can anyone suggest a clearer alternative?

1 Like

@darius thanks for the info, Appreciated

So…to bring this back to my original post: we often identify cases that “would be really good for OpenMRS in general if we could do xyz…if only someone had time to do this.” And I think there usually are people who could work on some priority item, if we were better able to communicate what’s a priority, the needed timeline, etc.

@tendomart, @samuel34, and others… is this the situation for you? Is this mainly a question of organization and communication?

So, are you suggesting that a (volunteer) solo dev could spend some time embedded with a particular implementation, but coming from the angle that part of their role is to figure out how to support the implementation’s specific needs by writing shared code in the platform and reference application?

Are there implementations open to formally taking on a volunteer in that capacity? Are there devs who would like to do that? Should this be brokered by the OpenMRS community somehow? Is it something like a fellowship?

This is great whenever it happens! Do you have ideas for how to foster more of it?

@darius I think it is.We definitly need to organise and communicate so that we can easily realise the goal , many times such an opportunity (two way) comes by ,but unless notified ,it may go unnoticed. It would be great teaming up with @samuel34 in a sprint to work on some Community Priority features.

How about Community Developer? That’s the term I used when defining community development roles several years ago.

I’ve always discouraged the use of “core devs” because of the term’s implied exclusivity… effectively reinforcing a culture of a small, exclusive club… which is the exact opposite of what we need. Instead, I think we should be encouraging commitments to the community and recognizing people and organizations making contributions to the public commons. If everyone (every organization, and every country) invested just 10% of the benefit they get from the shared OpenMRS commons back into the commons, we could sustain & grow it indefinitely. Such is the tragedy of the commons.

I completely upvote this. We can work on Community priority issues through sprints with other devs like @tendomart .

Thanks @darius for explaining this, at least your explanation has satisfied my questions.