#

General References

In the pursuit of scientific discovery, three formidable challenges often stand in our way: rigor, error, and sloppiness. These challenges, though daunting, can be tackled head-on by harnessing the powers of literacy, numeracy, and an efficient workflow. Welcome to Fena, a Jupyter-book designed to guide you through this transformative journey.

1. Fortifying Rigor through Literacy

Rigor is the backbone of any scientific project. It lends credibility, ensures quality, and paves the way for the reproducibility of results. However, the key to achieving rigor lies in literacy—not just in the conventional sense of being able to read and write, but in mastering the language of your specific scientific domain. Literacy in open science and self-publishing, as well as an in-depth understanding of how to successfully navigate and secure grants, empowers you with the tools needed to construct a rigorous scientific narrative. Through Chapters 10 to 12, Fena will help you attain a level of scientific literacy that is indispensable for establishing rigor in your work.

2. Mitigating Error through Numeracy

Error is the specter that haunts every researcher. It introduces uncertainty, casts shadows on results, and muddies the waters of interpretation. The most effective way to exorcise this specter is by building strong numeracy skills. Proficiency in programming languages such as Python, R, and Stata allows you to handle complex datasets, perform sophisticated analyses, and implement error-checking protocols. As you explore Chapters 7 to 9, you will acquire the numeracy skills crucial for minimizing error and enhancing the integrity of your data.

3. Combatting Sloppiness through Workflow Optimization

Sloppiness is often the silent killer of scientific projects. It creeps in unnoticed—through inconsistent data entry, haphazard code, or poorly organized files—and wreaks havoc when least expected. The best defense against sloppiness is a bulletproof workflow, a notion we delve into in Chapters 13 to 15. Utilizing automated .sh scripts, mastering the Unix command line, and embracing the principles of Bash programming can make your research process seamless, repeatable, and efficient.

Fena is not merely a handbook; it’s your compass in the scientific terrain fraught with these challenges. By the time you “turn the last page”, you will not only have the skill set to take on rigor, error, and sloppiness but also a strategic plan to propel your scientific journey forward.

Welcome aboard, and let’s get started.

Individual Projects

High School Students
Undergraduates
Graduate Students
Medical Students
Residents
Fellows
Graduates
Faculty
Analysts
Staff
Collaborators
Other

Personalized Path

Personalized Path

Imagine embarking on a journey through an exciting maze. Some paths are straight and easy, while others might be winding and require a bit more thought. With Fena, you have a map and compass to guide you, whether you’re just starting out or are an experienced explorer in the field of clinical research.

Whether you’re a high school student just getting started or a seasoned researcher, Fena offers the resources to navigate the diverse landscape of challenges that come your way. Our tools and community are here to help you turn these challenges into stepping stones towards success.

Our logo, a network of nodes & edges, is a symbol of our interconnectedness. It reflects our shared pursuit of medical progress and the bonds that tie us together in this exciting endeavor.

Join us at Fena, where we are all in this together, turning challenges into opportunities and striving for a brighter, healthier future.

The Balance of Flow

At Fena, we understand that success in clinical research is about finding the right balance. It’s about aligning your skills with the challenges you face, creating a state of optimal performance that psychologists call “flow.”

Below, you’ll find a visual representation of this principle:

Show code cell source Hide code cell source

import matplotlib.pyplot as plt
import numpy as np

# Create data for the skill and challenge levels
skill_levels = np.linspace(0, 10, 100)
challenge_levels = np.linspace(0, 10, 100)

# Define the flow channel boundaries
flow_channel = skill_levels

# Adjust the phase and amplitude of the sinusoid wave
phase = np.pi / 16
amplitude = 1.5
sinusoid = flow_channel + np.sin(skill_levels + phase) * amplitude

# Define the yellow zone boundaries, making it wider
yellow_zone_low = skill_levels - 1.5  # Adjust this value to make the yellow zone wider or narrower
yellow_zone_high = skill_levels + 1.5 # Adjust this value to make the yellow zone wider or narrower

# Plotting
plt.figure(figsize=(15, 10))

# Plot the anxiety and boredom areas
plt.fill_between(skill_levels, yellow_zone_high, 10, color='orangered', alpha=0.3, label='Place/Identification', interpolate=True)
plt.fill_between(skill_levels, 0, yellow_zone_low, color='lime', alpha=0.3, label='Time/Revelation', interpolate=True)
plt.fill_between(skill_levels, yellow_zone_low, yellow_zone_high, color='yellow', alpha=0.3, label='Agent/Evolution', interpolate=True)

# Plot the sinusoid function with the diagonal as its axis
plt.plot(skill_levels, sinusoid, color='purple', linestyle='-')

# Add arrowhead to the sinusoid line
plt.arrow(skill_levels[-2], sinusoid[-2], skill_levels[-1] - skill_levels[-2], sinusoid[-1] - sinusoid[-2],
          color='purple', length_includes_head=True, head_width=0.15, head_length=0.3)

# Set plot labels and title
plt.xlabel('Skill-level', fontsize=18)
plt.ylabel('Challenge-level', rotation='vertical', fontsize=18)

# Set plot limits and grid
plt.xlim(0, 10)
plt.ylim(0, 10)
plt.grid(True)

# Set tick labels
tick_labels = ['0', '2', '4', '6', '8', '10']
plt.xticks(np.linspace(0, 10, 6), tick_labels)
plt.yticks(np.linspace(0, 10, 6), tick_labels)

# Add text annotations to label the areas without shaded background
plt.text(1, 6, 'Anxious', color='black', ha='center', va='center', fontsize=18)
plt.text(4.5, 4.7, 'Flow', color='black', ha='center', va='center', fontsize=18)
plt.text(8, 3, 'Bored', color='black', ha='center', va='center', fontsize=18)

# Display the plot
plt.show()

_images/61614cff1f63ce716bbfe800aef5f16e0867dc75623431594aa07128bc19fe58.png

In this plot, the “flow” channel is where skill level and challenge level are in harmony. Stray too far above, and you may feel anxious or overwhelmed. Dip too far below, and boredom sets in. But within that channel, you’re in the zone of maximum productivity and enjoyment.

This platform’s key objective is to facilitate “flow,” a state of optimal performance where challenges are perfectly balanced with skills. By embracing tools such as Python, AI tools (ChatGPT and GitHub Copilot), R, Stata, and more, one should never be overwhelmed by the tasks encountered in clinical research.

We’re here to help you find your flow, guiding you through the complexities and empowering you to excel in your clinical research journey.

Contact Us/Enroll in our Courses

Contact us: muzaale@jhmi.edu, zjin26@jhmi.edu.
Enroll in our courses.

Visual Abstract of Fena

Show code cell source Hide code cell source

import networkx as nx
import matplotlib.pyplot as plt

# Set seed for layout
seed = 1234567890

# Directory structure
structure = {
    "Challenges": ["Fraud", "Sloppiness", "Rigor", "Learning", "Truth", "Error"],
    "Literacy": ["Grants", "Self-publish", "Knowledge-Gaps", "Open-Science", "Journals"],
    "Numeracy": ["Stata", "Estimates", "R", "AI", "Python"],  
    "Project": ["Manuscripts", "Git", "Code"],
    "Skills": ["Literacy", "Project", "Numeracy", "Workflow", "Challenges"],
    "Workflow": ["High School Students", "Undergraduates", "Graduate Students", "Medical Students", "Residents", "Fellows", "Faculty", "Analysts", "Staff", "Collaborators", "Graduates"],
}

# Gentle colors for children
child_colors = ["lightgreen", "lightpink", "lightyellow", 'white', 'honeydew', 'lightcoral','azure', 'lightblue','lavender']

# List of nodes to color light blue
light_blue_nodes = ["Literacy", "Numeracy", "You", "Project", "Challenges"]

G = nx.Graph()
node_colors = {}

# Function to capitalize the first letter of each word
def capitalize_name(name):
    return ' '.join(word.capitalize() for word in name.split(" "))

# Assign colors to nodes
for i, (parent, children) in enumerate(structure.items()):
    parent_name = capitalize_name(parent.replace("_", " "))
    G.add_node(parent_name)

    # Set the color for Skills
    if parent_name == "Skills":
        node_colors[parent_name] = 'lightgray'
    else:
        node_colors[parent_name] = child_colors[i % len(child_colors)]

    for child in children:
        child_name = capitalize_name(child.replace("_", " "))
        # Exclude "Co-Pilot" and "ChatGPT"
        if child_name not in ["Co-Pilot", "ChatGPT"]:
            G.add_edge(parent_name, child_name)
            if child_name in light_blue_nodes:
                node_colors[child_name] = 'lightblue'
            else:
                node_colors[child_name] = child_colors[(i + 8) % len(child_colors)]  # You can customize the logic here to assign colors

colors = [node_colors[node] for node in G.nodes()]

# Set figure size
plt.figure(figsize=(30, 30))

# Draw the graph
pos = nx.spring_layout(G, scale=30, seed=seed)
nx.draw_networkx_nodes(G, pos, node_size=10000, node_color=colors, edgecolors='black')  # Boundary color set here
nx.draw_networkx_edges(G, pos)
nx.draw_networkx_labels(G, pos, font_size=20)
plt.show()

_images/4bfd9ab0126a49a10a0f2137e73cc845e24835156c669a9f1e0e1ac32ca84146.png

A Visual Manifesto

A Visual Manifesto: Unveiling the Pillars of Fena’s Cartography of Excellence

Introduction Welcome once again to Fena, a world beyond just a Jupyter-book or a set of guidelines. It’s a living manifesto, crystallized in our logo, designed to be both your entry point and a continuous point of reference as you navigate the rich but challenging landscape of scientific research.

The Pillars of Excellence Fena identifies five critical pillars that guide your journey through scientific research:

Challenges (Humanity)
Project (Management)
Numeracy (Statistics)
Literacy (Writing)
Workflow (Tradition)

These pillars are not mere categories but the hub and spokes of a cartographic wheel that steers you toward conquering a crucial ‘Triumvirate in Scientific Research’: rigor, error, and sloppiness.

Challenges (Humanity): The Universal Struggle

At the core of Fena lies the understanding that our battles with rigor, error, and sloppiness are far from isolated issues within the realm of scientific research; they are the universal struggles that permeate every facet of human endeavor. Whether you are grappling with the rise of fake news in the media landscape or countering deep fakes in digital communication, these challenges have grown into overarching concerns for our society at large. Clinical research is but a single domain within this complex mosaic, offering us a specific but deeply connected set of problems to solve as part of humanity’s broader quest for truth and excellence.

In this way, Fena serves not only as a guide for researchers but also as a compass for anyone navigating these universal challenges, lending its principles and strategies to help us find our footing on this diverse ground of human struggle and aspiration.

Project (Management): The Blueprint This pillar focuses on the importance of effectively planning, executing, and closing research initiatives, serving as the blueprint for your scientific endeavors.

Numeracy (Statistics): The Fortifications In the domain of Numeracy, Python, R, and Stata stand not just as tools but as fortifications against error, encapsulating the statistical might required to deliver credible results.

Literacy (Writing): The Compass Literacy, represented by nodes like ‘Grants’ and ‘Open Science’, is your compass in the quest for rigor. It’s not simply about being able to read and write but mastering the intricate language of your specific scientific domain.

Workflow (Tradition): The Collective Shield Sloppiness can be a silent research assassin. The pillar of Workflow involves everyone from high school students to faculty, emphasizing that the fight against sloppiness is a collective effort, solidified by a unified, efficient workflow.

Conclusion: The Dynamic, Interconnected Journey
Fena is not a static guide; it’s an evolving universe. The spring layout of our logo and the cohesive tapestry of skills represented in this Jupyter-book serve as your dynamic blueprints, forever adaptable yet always focused on achieving research excellence.

So as you embark on this journey with Fena, remember that these pillars and pathways are here to transform your scientific expedition from a maze of challenges into an odyssey of enlightenment.

Welcome aboard Fena, where the pursuit of scientific excellence is both a universal endeavor and an attainable reality.

Edit the Content of Fena

Introduction

Fena is more than a static set of guidelines or a closed-door manifesto; it’s a dynamically evolving Jupyter-book hosted as a public repository on GitHub. This opens up the floor for contributions from everyone who wishes to join us on this journey toward scientific excellence.

How You Can Contribute

Fork and Clone: To get started, simply fork the Fena repository to your GitHub account, and then clone it locally to make changes.
Issues and Pull Requests: Have a new idea, correction, or data to add? Open an issue for discussion or directly submit a pull request. Both are valuable means of contributing.
Code and Data: Given the Jupyter-book architecture, contributions aren’t limited to text. Add code snippets, Jupyter notebooks, or data sets to enrich the ‘Numeracy (Statistics)’ pillar.
Documentation: The ‘Literacy (Writing)’ pillar could always use more guides, tutorials, and grant-writing tips. Feel free to update or add new content.
GitHub Pages Deployment: Help us improve the UI/UX or optimize the GH-Pages deployment process to make Fena more accessible.

The Process

Review Current Branches: Before contributing, please review the existing branches and pull requests to avoid duplication of effort.
Create a New Branch: Always make changes in a new branch. This makes it easier for maintainers to manage contributions.
Peer Review: Once you’ve pushed your changes, create a pull request for peer review.
Merging and Acknowledgment: After a successful review, your contributions will be merged into the main branch. All contributors are acknowledged in the contributors’ list, because Fena is a collective endeavor.

Conclusion

Your contributions are what make Fena a living, breathing entity. By leveraging the open-source capabilities of GitHub and the dynamic interactivity of Jupyter-books, Fena aims to be a continually evolving resource. Your expertise, insights, and fixes are not just add-ons; they’re essential chapters in this unfolding narrative of scientific discovery.

So go ahead, fork the repo, open that pull request, and become an active member of the Fena community. Together, we’re not just writing a book; we’re scripting an odyssey.