Coder

From LMU BioDB 2017
Jump to: navigation, search
GRNsight Gene Page Project Links
Overview Deliverables Reference Format Guilds Project Manager Quality Assurance Data Analysis Coder
Teams Page Desiigner Lights, Camera, InterACTION! Gene hAPI JASPAR the Friendly Ghost

The coder is the resident expert on the technology being used—assorted software, file management, version control, troubleshooting, programming. He or she coordinates with Drs. Dahlquist and Dionisio and fellow coders in developing the code base for the GRNsight gene page. GRNsight is written in JavaScript and is built on open source JavaScript libraries. Source code is hosted on GitHub and managed by Node.js.

Guild Members

  • Page Design: Arash (Coder), Nicole (Designer)
  • Gene Database APIs: Eddie A. and John
  • JASPAR API: Eddie B. and Simon
  • Interaction and Integration: Blair and Zach

Milestones

The milestones do not necessarily correspond to particular weeks; instead they are sets of tasks grouped together. However, Milestones 1-3 are hard prerequisites for proceeding to Milestone 4, so ideally the Coder guild should finish these milestones (they require some coordination; see below) as soon as possible. The Coder guild should be working within the Milestone 4-5 cycle by Week 12 at the latest.

Milestone 0: Journal Club Presentation

  • For the Week 11 assignment, the Coders (including Designers) of each team will prepare a PowerPoint presentation of their respective assigned software design/development/engineering/best practices reading to be delivered in class on Tuesday, November 14.

Milestone 1: Working Environment Setup

Coder work will require the following software. The Seaver 120 lab computers are already set up for this; this list is provided for Coders who need to work on a different computer or outside of the lab.

  • Node.js 8.4.0 or newer
  • Code-savvy editor such as Atom or Microsoft Visual Studio Code
  • Web browser with developer tools (Seaver 120 uses Google Chrome)
  • git version control software
  • (depends on team) curl command

Make sure that this software is installed and operational before beginning. If any Coder needs help with any of these packages, please consult your fellow guild members or ask Dr. Dionisio.

Milestone 2: Version Control Setup

Coding work will be done on a fork of the open source GRNsight project, which is hosted on GitHub. The software that interacts with GitHub to perform version control is git. If any Coder needs help with git or version control concepts in general, please consult your fellow guild members or ask Dr. Dionisio.

The Interaction and Integration team is responsible for this fork, and will do their own work on the master branch of this fork. Thus, many of the early steps in this procedure involve them, and they must accomplish these steps first before the others can proceed:

  1. All members of the Coder guild should acquire a GitHub account, if they don’t already have one (it’s free).
  2. One of the Coders of the Interaction and Integration team creates a fork of the GRNsight project.
  3. The Interaction and Integration team adds the GitHub accounts of all Coder guild members as collaborators on the fork.
  4. Once every team is a collaborator on this fork, they can then create their respective branches on the fork:
    • The Page Design team creates a branch called page-design.
    • The Gene Database APIs team creates a branch called gene-database-apis.
    • After the gene-database-apis branch is created, the JASPAR API team creates a branch from gene-database-apis called jaspar-api.

The teams will then do their work on their respective branches. The protocol for integrating your work is described in the Integration and Integration Testing milestone below.

The structure described in this milestone is a typical GitHub fork-and-branch approach which some Coders are already familiar with. If any Coder needs help with this methodology, please consult your fellow guild members or ask Dr. Dionisio.

Milestone 3: “Developer Rig” Setup and Initial As-Is Build

Before development can begin in earnest, the following initial setup steps must be performed per Coder after version control setup is complete:

  1. git clone the GitHub fork created in the version control setup milestone on where you plan to work on the project.
  2. cd into the folder that contains the cloned repository
  3. git checkout the branch that is assigned to you:
    • Interaction and Integration: master (no need for an explicit checkout because the clone defaults to this branch)
    • Page Design: page-design
    • Gene Database APIs: gene-database-apis
    • JASPAR: jasper-api (note that as instructed above, this should be a branch of the gene-database-apis branch)
  4. Follow the instructions in the GRNsight wiki to perform the following:
    1. Installation of necessary third-party libraries
    2. Initial startup of the GRNsight application on your computer

If anyone runs into problems with this procedure, please consult with your fellow guild members or notify Dr. Dionisio.

Milestone 4: Development, Implementation, and Localized Testing

At this point, each team proceeds with their own development work. In general, each team will do most of their work (and place most of their files) in the following locations within the GRNsight repository. Some files may need to go elsewhere; check in with Dr. Dionisio if there are any file organization/location issues:

  • Page Design: web-client/public/html (this folder does not yet exist; you will need to create it) and web-client/test (in case you are able to write unit tests for your work)
  • Gene Database APIs: web-client/public/js and web-client/test
  • JASPAR: web-client/public/js and web-client/test
  • Interaction and Integration: Because you are integrating the other teams’ work, you will likely interact with the entire web-client folder

For the Gene Database APIs and JASPAR teams, your work will not be visible to end-users until the first overall integration is done, so use unit tests as your initial approach for verifying that your code is working well. You will probably need to mock up your API calls so that you don’t bombard the web services with requests while unit testing. However, these sites are generally open access so you can probably write your initial set of tests using real requests and responses.

The Quality Assurance members of each team should take charge of manual testing. Specific suggested manual testing tasks are described in the Quality Assurance guild page.

The Interaction and Integration team should initially get to know the files being created and worked on by the other teams prior to the first integration milestone.

Teams should perform their own internal testing (both manual and automated) on their respective files throughout development. Commit and push your work to your designated branch at appropriate intervals. Coders who are not familiar with this style of working should consult with fellow guild members or talk to Dr. Dionisio.

Milestone 5: Integration and Integration Testing

Integration and integration testing should take place periodically to make sure that the overall gene page project is coming together well. Most of the Coders’ work for the remainder of the semester will be a cycle of the development and integration milestones. The Interaction and Integration team is in charge of coordinating when these integrations take place. The first integration will likely be the most difficult one to perform, but it is hoped that later iterations will proceed more smoothly.

When the other teams have reached the following sub-milestones, the first integration cycle can take place. Future iterations are at the discretion of the Interaction and Integration team in coordination with how the other teams are progressing:

  • Page Design: first working version of the gene page
  • Gene Database APIs: first working version of the getGeneInformation function
  • JASPAR: This team’s work does not have to participate in the first integration cycle; instead, they should integrate their work with the Gene Database APIs team whenever they have a working prototype. JASPAR functionality simply “shows up” at some future integration cycle.
  • Interaction and Integration: You are not blocked from working prior to the first integration; you can work on exploring the existing GRNsight code to implement the right-click functionality that will open the gene page in a new tab or window. You can start by making this code open a blank page. Upon the first integration iteration, you can then connect that page to the gene page provided by the Page Design team.

An individual integration iteration proceeds in this way:

  1. The Page Design and Gene Database APIs teams issue pull requests to merge their branches with the master branch.
  2. The Coders guild reviews each other’s code and points out any needed revisions.
  3. Once all revision requests are fulfilled, the Interaction and Integration team merges the pull requests into master.
  4. The Coders guild resolves any merge conflicts then tests the combined code.
  5. The combined code is allowed to be unfinished, but it should not be broken. The combined GRNsight build should still run and show steady progress toward the fully-envisioned gene page functionality.
  6. Code revisions at this stage are committed and pushed to master.
  7. When the Interaction and Integration team is satisfied with the state of the combined code, the other teams can then merge master back into their respective branches, and localized development and testing can proceed to the next phase.
  8. When the teams feel that they have reached another integration point, they notify the Interaction and Integration team of this and another integration iteration can take place.
  9. Rinse and repeat until the project is done!
GRNsight Gene Page Project Links
Overview Deliverables Reference Format Guilds Project Manager Quality Assurance Data Analysis Coder
Teams Page Desiigner Lights, Camera, InterACTION! Gene hAPI JASPAR the Friendly Ghost