# How to Learn Bioinformatics with Rosalind Working through this guide gives you three things: a Python workspace you will keep using, correct solutions to the first problems on Rosalind, and a repeatable loop for every problem after that. Rosalind is a free platform at rosalind.info that teaches bioinformatics and programming through short problems with instant grading. By the end of this walkthrough you will have counted nucleotides, transcribed DNA into RNA, built reverse complements, parsed FASTA files, computed GC content, counted point mutations, and modeled a growing population with a recurrence relation. Have these on hand before you start: - Python 3.9 or newer, installed and runnable from a terminal - A text editor. Visual Studio Code is free and runs on Windows, macOS, and Linux - A terminal or command prompt - A free Rosalind account, which you need in order to download problem datasets - Sessions of roughly 30 to 60 minutes No programming background is needed for the first problems, and no [biology degree](/blog/careers/biology-degree) is needed either. The problem statements teach the biology as they go. Every script in this guide uses only the Python standard library, so there is nothing to install beyond Python itself. If you arrived after searching for a rosalind bioinformatics tutorial, this guide goes further than a problem list. It shows the commands, the code, the expected output, and the exact errors you will hit along the way. The approach matters beyond one website. A roadmap for cancer systems biology frames modern biology's core task as understanding disease as a system of interconnected molecules, cells, and tissues, which depends on computational and analytic technologies that capture complexity at multiple scales [1]. Learning to code against sequence data is the entry point to that world. ## Why Rosalind Works for Learning Bioinformatics Most people try to learn bioinformatics by watching videos and then freeze the first time a real file appears on screen. Rosalind inverts that. Every problem hands you an actual dataset and demands an exact answer, so you are practicing from minute one. Four design choices make it work: 1. **One concept per problem.** The first problem only counts letters in a string. The second only swaps characters. Complexity arrives one step at a time, the way good bioinformatics tutorials have always worked. A long-running tutorial series in [Briefings in Bioinformatics](/blog/guides/briefings-in-bioinformatics) introduced protein domains and motifs to newcomers in deliberately bite-sized chunks [2]. 2. **Instant, literal grading.** The grader compares your answer character for character. That trains the habit of reading specifications carefully, which separates working pipelines from broken ones in real research. 3. **Biology embedded in the statements.** Each problem defines its own terms, so you learn what GC content or an open reading frame is at the exact moment you compute one. 4. **Compounding skills.** The FASTA parser you write in week one gets reused in dozens of later problems. The recurrence ideas from early problems return as dynamic programming in harder ones. Rosalind is practice, not a full curriculum. A structured [bioinformatics course](/blog/careers/bioinformatics-courses-and-certifications-a-practical-guide) adds statistics, experimental design, and domain depth that puzzles cannot. The two fit together well: course or textbook for theory, Rosalind for repetitions. ## How Rosalind Is Organized Rosalind is named for Rosalind Franklin, whose X-ray diffraction images were essential to solving the structure of DNA, and it borrows its format from Project Euler, the mathematics problem site. You create a free account, open a problem, download a dataset generated for your account, and submit an answer string. Correct answers earn points and mark the problem solved on your profile. The problems live in five locations: - **Python Village.** Programming from zero: variables, strings, loops, conditionals, file reading, and dictionaries. Start here if you have never coded. - **Bioinformatics Stronghold.** The main sequence of bioinformatics problems, from nucleotide counting through motif finding, translation, phylogeny, and genome assembly concepts. Most of your time belongs here. - **Algorithmic Heights.** Classical algorithms such as binary search, sorting, and dynamic programming, framed with bioinformatics flavor. - **Bioinformatics Armory.** Problems meant to be solved with existing tools rather than code written from scratch. - **Textbook Track.** Problems paired with the Bioinformatics Algorithms textbook by Phillip Compeau and Pavel Pevzner, useful if you want a written companion. Every problem page has the same anatomy. The Problem section explains the biology and the task. Given and Return state exactly what input you receive and what output to produce. A Sample Dataset and Sample Output let you test before submitting. A Download dataset button generates your actual dataset, tied to your account, so answers from another person will not match. Later problems build on earlier ones, which rewards solving the track in order. ## Setting Up a Workspace You Can Keep Rosalind runs in the browser, but your code should live on your machine in a folder you control. Set it up once and every future problem starts faster. Check Python first: ```bash python3 --version ``` You want a line such as `Python 3.12.4`. Any version 3.9 or newer works. On Windows the command may be `py, version` or `python, version` instead. Create a project folder, a virtual environment, and a git repository: ```bash mkdir -p ~/rosalind/solutions cd ~/rosalind python3 -m venv .venv source .venv/bin/activate git init echo ".venv/" > .gitignore ``` On Windows PowerShell, activate the environment with: ```powershell .venv\Scripts\Activate.ps1 ``` A virtual environment is a private copy of Python for this project, so packages you install later never clash with your system Python. Git is version control, it snapshots your solutions so you can always roll back. Both take one command now and save hours later. Adopt one convention and keep it: one script per problem, named after the problem ID, with the downloaded dataset saved beside it. Your folder fills up like this: ``` rosalind/ .venv/ solutions/ dna.py sample_dna.txt rosalind_dna.txt gc.py sample_gc.txt rosalind_gc.txt ``` Start every problem from the same template: ```python import sys def solve(data: str) -> str: return data # replace this body for each problem def main() -> None: with open(sys.argv[3]) as fh: data = fh.read().strip() print(solve(data)) if __name__ == "__main__": main() ``` `sys.argv` is the first argument after the script name, so `python3 dna.py rosalind_dna.txt` passes the dataset path in. The `with open(...)` block closes the file for you, and `strip()` removes the trailing newline that text files carry. Two errors show up immediately for everyone. If you forget the filename argument you get: ``` IndexError: list index out of range ``` Fix: pass the dataset path after the script name. If the path is wrong you get: ``` FileNotFoundError: [Errno 2] No such file or directory: 'rosalind_dna.txt' ``` Fix: run `pwd` (or `cd` with no arguments on Windows) to see your current directory, then `ls` (or `dir`) to confirm the file is where you think it is. ## A Rosalind Bioinformatics Tutorial, Step by Step The walkthrough below solves six Stronghold problems in order, with commands, code, expected output, and the trap hiding in each. The table maps the whole set before you start. | Problem | ID | Skill you practice | Key function or formula | Common pitfall | |--|--|--|--|--| | Counting [DNA nucleotides](/blog/guides/dna-nucleotides) | DNA | String counting | `seq.count(n)` for each of A, C, G, T | Output order must be A, C, G, T | | Transcribing DNA into RNA | RNA | Character replacement | `seq.replace("T", "U")` | Replacing U with T instead | | Complementing a strand | REVC | Two operations at once | `str.maketrans("ACGT", "TGCA")` plus `[::-1]` | Complementing but forgetting to reverse | | Computing GC content | GC | FASTA parsing, percentages | 100 × (G + C) ÷ length | Counting headers as sequence, ignoring line breaks | | Counting point mutations | HAMM | Position-wise comparison | `sum(x != y for x, y in zip(a, b))` | Unequal lengths truncate silently | | Rabbits and recurrence relations | FIB | Recursion with caching | W(n) = W(n-1) + W(n-2) × k | Naive recursion without a cache | ### Step 1. Create an account and download the first dataset Register at rosalind.info with an email and a password. Open Locations, choose Bioinformatics Stronghold, and open the problem titled Counting DNA Nucleotides (ID: DNA). Read the Problem, Given, and Return sections completely before touching code. Click Download dataset and save the file as `rosalind_dna.txt` inside your solutions folder. The dataset is generated for your account, so your answer will differ from anyone else's. ### Step 2. Solve the sample by hand The sample dataset is a single DNA string, a sequence over the alphabet A, C, G, T. The problem asks for the counts of A, C, G, and T, in that order, separated by single spaces. Take a short string such as `AGCTTTCAGC` and count on paper: A appears 2 times, C 3 times, G 3 times, T 2 times. The expected output is: ``` 2 3 3 2 ``` If you cannot produce a sample output by hand, you are not ready to code the problem yet, and that check costs one minute. ### Step 3. Count nucleotides (DNA) ```python import sys def solve(seq: str) -> str: return f"{seq.count('A')} {seq.count('C')} {seq.count('G')} {seq.count('T')}" def main() -> None: with open(sys.argv[3]) as fh: seq = fh.read().strip() print(solve(seq)) if __name__ == "__main__": main() ``` `str.count` returns the number of occurrences of a substring, and the f-string joins the four counts with single spaces. Test on a sample you control: ```bash echo "AGCTTTCAGC" > sample_dna.txt python3 dna.py sample_dna.txt ``` Output: ``` 2 3 3 2 ``` Now run on the real dataset: ```bash python3 dna.py rosalind_dna.txt ``` You get one line of four integers. Copy it exactly, paste it into the answer box on the problem page, and submit. A correct answer is confirmed immediately and adds points to your profile. ### Step 4. Transcribe and reverse complement (RNA, REVC) Transcription replaces every thymine (T) with uracil (U). One line does it: ```python def solve(seq: str) -> str: return seq.replace("T", "U") ``` For example, `GATCGA` becomes `GAUCGA`. The reverse complement problem (REVC) asks for two operations at once. DNA is double stranded, and the second strand runs in the opposite direction, so its sequence is the complement (A paired with T, C paired with G) read backwards. Tools that search both strands of a genome need this constantly. Build a translation table with `str.maketrans`, apply it, then reverse with slice notation: ```python def solve(seq: str) -> str: return seq.translate(str.maketrans("ACGT", "TGCA"))[::-1] ``` The sample dataset `AAAACCCGGT` returns: ``` ACCGGGTTTT ``` `maketrans("ACGT", "TGCA")` maps each base to its pairing partner, and `[::-1]` is Python's whole-string reverse slice. ### Step 5. Parse FASTA and compute GC content (GC) ![Worked calculation of GC content for Rosalind_0002, showing 6 G or C bases out of 10 giving 60.000000 percent.](/article-images/illustrations/rosalind-bioinformatics-tutorial-gc-content-calc.webp) FASTA is the standard text format for biological sequences. Each record starts with a header line beginning with `>`, followed by one or more sequence lines. Real records span many lines, so you must join the lines before counting anything. GC content is the percentage of bases in a sequence that are G or C. It varies between species and between genomic regions, which is why it shows up in [sequencing quality control](/knowledge/diagnostics/molecular/understanding-sequencing-quality-control-metrics-and-best-practices) and in separating mixed samples. The GC problem gives several FASTA records and asks for the ID and GC content of the record with the highest value. Save this as `sample_gc.txt`: ``` >Rosalind_0001 GATCGATCGA >Rosalind_0002 GATCGGATCG >Rosalind_0003 ATATATATAT ``` By hand: record 0001 has 5 G or C bases out of 10, so 50.0. Record 0002 has 6 out of 10, so 60.0. Record 0003 has 0. The winner is Rosalind_0002. ```python import sys def parse_fasta(text: str) -> dict: records = {} name = None chunks = [] for line in text.splitlines(): line = line.strip() if line.startswith(">"): if name is not None: records[name] = "".join(chunks) name = line[1:].split() chunks = [] elif line: chunks.append(line) if name is not None: records[name] = "".join(chunks) return records def gc_percent(seq: str) -> float: return 100.0 * (seq.count("G") + seq.count("C")) / len(seq) def main() -> None: with open(sys.argv[3]) as fh: records = parse_fasta(fh.read()) best_id = max(records, key=lambda k: gc_percent(records[k])) print(best_id) print(f"{gc_percent(records[best_id]):.6f}") if __name__ == "__main__": main() ``` Run it: ```bash python3 gc.py sample_gc.txt ``` Output: ``` Rosalind_0002 60.000000 ``` Three details matter here. `line[1:].split()` drops the `>` and keeps the first token of the header, which is the ID. `max` with a `key` function walks the records and returns the ID whose GC content is highest. The format spec `.6f` prints six digits after the decimal point, matching the style of the sample output on the problem page. Check your parser against the real file before trusting it: ```bash grep -c ">" rosalind_gc.txt ``` This prints the number of FASTA records in the dataset. If your dictionary does not hold that many keys, the parser is dropping records. A classic failure at this step is trying to parse a header line as a number: ``` ValueError: invalid literal for int() with base 10: '>Rosalind_0001' ``` Fix: skip lines that start with `>` before any numeric conversion. ### Step 6. Count point mutations (HAMM) A Hamming distance is the number of positions at which two equal-length strings differ. It is the simplest sequence distance, and the same position-wise comparison idea scales up to alignment scoring in later problems. The HAMM problem gives two DNA strings of equal length and asks for that count. The sample strings are `GAGCCTACTAACGGGAT` and `CATCGTAATGACGGCCT`. Comparing position by position gives 7 differences. ```python import sys def hamming(a: str, b: str) -> int: if len(a) != len(b): raise ValueError("sequences must be the same length") return sum(x != y for x, y in zip(a, b)) def main() -> None: with open(sys.argv[3]) as fh: a = fh.readline().strip() b = fh.readline().strip() print(hamming(a, b)) if __name__ == "__main__": main() ``` ```bash printf "GAGCCTACTAACGGGAT\nCATCGTAATGACGGCCT\n" > sample_hamm.txt python3 hamm.py sample_hamm.txt ``` Output: ``` 7 ``` `zip` pairs characters position by position, and summing booleans counts the mismatches. The length guard exists because `zip` silently stops at the shorter string, which would turn a truncated file into a wrong answer instead of an error. ### Step 7. Grow rabbits with a cached recurrence (FIB) The FIB problem introduces recurrence relations, where each term is defined from earlier terms. The setup: one breeding pair of rabbits, every mature pair produces k new pairs each month, and rabbits mature after one month. The count follows W(1) = 1, W(2) = 1, and W(n) = W(n-1) + W(n-2) × k. Work the sample n = 5, k = 3 by hand. Month 3: 1 + 3 = 4 pairs. Month 4: 4 + 3 = 7 pairs. Month 5: 7 + 12 = 19 pairs. ```python import sys from functools import lru_cache @lru_cache(maxsize=None) def rabbits(months: int, litter: int) -> int: if months <= 2: return 1 return rabbits(months - 1, litter) + rabbits(months - 2, litter) * litter def main() -> None: with open(sys.argv[3]) as fh: months, litter = (int(x) for x in fh.read().split()) print(rabbits(months, litter)) if __name__ == "__main__": main() ``` ```bash echo "5 3" > sample_fib.txt python3 fib.py sample_fib.txt ``` Output: ``` 19 ``` `lru_cache(maxsize=None)` is memoization, it stores every result so each subproblem is computed once. Without it, each call spawns two more calls and the total work doubles every month, so even n = 35 stalls. Memoization is the doorway to dynamic programming, which later Stronghold problems use constantly for edit distance and alignment. ### Step 8. Verify, submit, and record Before submitting anything, check the output mechanically rather than by eye. Save the sample output from the problem page into a file, then: ```bash python3 gc.py sample_gc.txt > my_output.txt diff my_output.txt sample_gc_expected.txt ``` `diff` prints nothing when the files match, which is the result you want. Then run your script on the downloaded dataset, paste the result into the answer box, and submit. After the confirmation, write one line in a notes file: ```markdown ## GC - FASTA sequences span multiple lines, join before counting - output wants six decimal places, use f"{x:.6f}" ``` That notes file becomes the most useful artifact of the whole project, because it records the tricks in your own words. ## A Reusable Workflow for Every New Problem Every problem after these six follows the same loop. 1. Read the full statement, including the [biology background](/blog/careers/biology-background) paragraphs. 2. Solve the sample dataset by hand where you can. 3. Copy your template, implement `solve()`. 4. Test against the sample and diff the outputs. 5. Run on your downloaded dataset and submit. 6. Write one line in `notes.md` about the trick you learned. Pacing matters more than intensity. Two or three problems per session, three sessions a week, beats a ten-problem weekend binge you never repeat. The Stronghold orders its problems so later ones reuse earlier ideas, which means gaps compound, so solve in order and do not skip. Stuck past 45 minutes? Read the hint if the page offers one. Still stuck? Stop for the day and return tomorrow. Problems that resist an evening often fall in ten minutes the next morning. Once a week, redo one solved problem from a blank file without looking at your old code. If you cannot, reread your notes before moving on. This loop is the honest answer to how to learn bioinformatics with Rosalind: the platform supplies the problems, and the loop supplies the learning. Keep pairing practice with theory. The Textbook Track maps onto the Bioinformatics Algorithms textbook, and any structured bioinformatics course can run alongside Rosalind as its problem set. Theory tells you why an algorithm works, and the problems make your hands able to run it. ## Rosalind Bioinformatics Tutorial Tips That Speed You Up These rosalind bioinformatics tutorial tips come from the failure modes that cost beginners the most time: - **Solve the sample by hand first.** If you cannot produce the sample output on paper, you do not understand the transformation yet, and coding will only hide that. - **Keep `solve()` pure.** One string in, one string out, no printing inside. Testing becomes a one-liner and you can reuse the function in later problems. - **Build a snippet library.** Copy your FASTA parser forward into every problem that needs it. Dozens of Stronghold problems take FASTA input, and rewriting the parser each time wastes the point of learning it once. - **Use `collections.Counter` for counting problems.** `Counter(seq)` returns per-character counts in one call, which replaces four `.count()` invocations. - **Match the output format character for character.** Extra spaces, wrong order, or different rounding all fail. The grader is literal, and that is a feature. - **Verify with `diff`, not by eye.** Eyes forgive trailing spaces and missing newlines. `diff` does not. - **Read the biology paragraphs in each statement.** They define the terms and explain why anyone computes this. Skipping them turns the Stronghold into a typing exercise. - **Timebox at 45 minutes, then use the hint, then stop.** Grinding past that point teaches frustration rather than bioinformatics. - **Type every line yourself.** Pasting a solution from a forum, or accepting a chatbot's answer wholesale, gets you the points and leaves you stuck two problems later when the same idea returns inside a harder one. - **Revisit old problems in a second language.** Solving REVC again in R or C after a month tests whether you learned the concept or only the Python call. ## From Rosalind Problems to Real Pipelines Rosalind datasets are small and clean. Real analysis is not. A single sequencing run produces millions of short reads with per-base quality scores in [FASTQ format](/knowledge/bioinformatics/fastq-file-format-phred-scores-qc), and the work shifts from solving puzzles to chaining tools into pipelines that run on servers or cloud machines. What transfers completely is the habit set: parse formats exactly, check outputs mechanically, and never trust data you have not inspected. The destination looks like this. One published antimicrobial resistance study ran a genome-wide association study (GWAS), a scan of many genomes for variants correlated with a trait, on 662 Streptococcus pneumoniae genomes, validated candidate resistance mutations in the folA and sulA loci by reconstructing them in the laboratory, and trained machine learning models that predicted trimethoprim minimum inhibitory concentration (MIC), the lowest antibiotic concentration that stops bacterial growth, within one twofold dilution for 86.3% of isolates on average [4]. That is the arc Rosalind starts you on, from sequence files to validated biology. Modern pipelines are integrated end to end. A review of microRNA analysis in precision oncology describes workflows that run from next-generation sequencing (NGS) data processing through multi-omics integration, layer on model families such as support vector machines, convolutional neural networks, and recurrent neural networks, and treat reproducibility as a requirement for clinically actionable results [5]. The discipline that makes pipelines trustworthy is procedural rather than mathematical. A data science roadmap from an open science drug discovery organization recommends precise ontologies and standardized vocabularies for managing data, transparent and reproducible data processing, carefully chosen training and test sets, and explicit estimates of prediction uncertainty [6]. Notice how much of that you can start practicing on Rosalind: exact formats, mechanical verification, and notes you can retrace weeks later. Real projects also live inside data ecosystems. When data sit in many separate resources, federation, connecting databases so each stays under local control while queries span them, is the recommended pattern in fields such as exposomics [7]. Machine learning now reaches knowledge work too, with published pipelines that classify scientific literature and extract [structured data](/blog/data-analysis/what-is-structured-data), evaluated with precision, recall, and F1 scores [8]. Sensible next steps after the early Stronghold, in order: learn the shell beyond the basics (`cd`, `ls`, `grep`, `awk`), learn a workflow manager such as Snakemake or Nextflow, take a statistics course, and point your skills at one real public dataset from download to figure. ## Common Mistakes and Limitations ![Side by side comparison of the DNA, GC, HAMM and FIB problems showing input, key operation and exact output format.](/article-images/illustrations/rosalind-bioinformatics-tutorial-problem-output-formats.webp) These are the common mistakes that show up in almost everyone's first month on Rosalind, with the fix for each: - **Submitting the sample output.** The sample is for testing your code. The graded answer must come from the dataset you downloaded, which is unique to your account. - **Counting FASTA headers as sequence, or ignoring line breaks.** Symptoms are counts that are too high and GC content that is slightly off. Fix: join all sequence lines per record before counting, and never count lines that start with `>`. - **Off-by-one slicing.** Python slices exclude the end index, so `seq[0:3]` returns three characters, not four. Motif and [RNA splicing](/blog/guides/rna-splicing) problems punish this constantly. - **Uncached recursion.** Plain recursion on FIB doubles the work every month, and n around 35 hangs. Fix: `lru_cache`, or an iterative loop. - **Assuming clean input.** Sequences can contain N, the code for an unknown base, plus stray whitespace. Write parsers that strip lines, skip blanks, and never assume every character is A, C, G, or T. - **Wrong output format.** The DNA problem wants the order A, C, G, T. The GC sample output shows six decimal places. Reread the Return section before submitting, and diff against the sample. - **Type confusion.** Adding a number to a string raises: ``` TypeError: can only concatenate str (not "int") to str ``` Fix: convert deliberately with `int()` or `str()`. - **Rounding too early.** Keep full float precision through the calculation and format only at print time. Rounding inside the loop accumulates error. - **Outsourcing the thinking.** The grader cannot tell who wrote your code, which is exactly why copied answers feel safe and are not. Later problems combine two or three earlier ideas in ways no pasted answer anticipates. Rosalind also has honest limits. Its datasets are small and clean by design, while real sequencing data brings quality control, alignment, and scale problems that need workflow tooling on servers or cloud systems. It teaches no statistics and no experimental design, which a bioinformatics course and domain reading supply. Sequence puzzles are the foundation of the field, not its ceiling. Writing in 2004, the Briefings in Bioinformatics tutorial series observed that predicting protein tertiary structure and chemical function from [amino acid sequence](/blog/guides/amino-acid-sequence) alone had resisted decades of effort, with the folding problem still a hurdle [2]. The lesson stands: string operations are the beginning of bioinformatics, not the end. Real projects carry constraints no puzzle site can simulate. Work on cross-border pediatric health data sharing documents barriers such as non-standardized consent, multi-site ethics review, and governance frameworks that must align with institutional and regulatory requirements [3]. And individual research questions, especially clinical or publication-bound ones, deserve an experienced collaborator before you act on your own analysis. ## Frequently Asked Questions ### Is Rosalind suitable for complete beginners? Yes. Python Village assumes no programming experience and walks you through variables, strings, loops, file reading, and dictionaries before the main Bioinformatics Stronghold track begins. ### How long does it take to learn bioinformatics with Rosalind? It depends on your starting point and pace. Most self-directed learners spend a few months in the early tracks at two or three problems per session, and the platform sets no official completion time. ### Do I need a biology background before starting? No. Each problem statement defines the biology it uses, so you pick up terms such as GC content, motif, and open reading frame while solving. ### Which programming language should I use on Rosalind? Python is the most common choice and the language Python Village teaches, but the grader checks your answer text rather than your code, so any language works. ### Is Rosalind free to use? Yes. Registration is free, every problem and dataset is free, and there is no paid tier. ### What should I do after finishing the Bioinformatics Stronghold? Move to real data and full pipelines. Reapply your skills to a public sequencing dataset, learn a workflow manager such as Snakemake or Nextflow, and pair practice with a structured bioinformatics course or textbook. ### Can Rosalind help me get a bioinformatics job? It builds demonstrable core skills, but employers also want project experience with real data. Use solved concepts as the base for a small portfolio project that processes a public dataset end to end. ### Can I solve Rosalind problems in R or another language? Yes. Because you submit an answer string rather than code, R, Julia, C, or even a spreadsheet can produce a correct submission for many problems. ## Sources 1. [A Roadmap for the Future of Systems Biology in Cancer Research.](https://pubmed.ncbi.nlm.nih.gov/41091803/) 2. [Tutorial section: domains and motifs - proteins in bite-sized chunks.](https://pubmed.ncbi.nlm.nih.gov/15153307/) 3. [A roadmap for navigating child health research data sharing across Canada and beyond - building on UCAN CAN-DU.](https://pubmed.ncbi.nlm.nih.gov/40898230/) 4. [Holistic understanding of trimethoprim resistance in Streptococcus pneumoniae using an integrative approach of genome-wide association study, resistance reconstruction, and machine learning.](https://pubmed.ncbi.nlm.nih.gov/39120145/) 5. [MicroRNA bioinformatics in precision oncology: an integrated pipeline from NGS to AI-based target discovery.](https://pubmed.ncbi.nlm.nih.gov/41168533/) 6. [A data science roadmap for open science organizations engaged in early-stage drug discovery.](https://pubmed.ncbi.nlm.nih.gov/38965235/) 7. [A roadmap to advance exposomics through federation of data.](https://pubmed.ncbi.nlm.nih.gov/39267798/) 8. [Machine Learning Approach to Facilitate Knowledge Synthesis at the Intersection of Liver Cancer, Epidemiology, and Health Disparities Research.](https://pubmed.ncbi.nlm.nih.gov/35623021/)