Software Engineering
For Genomics and Life Sciences
Software Project Management
- Scope: Define and manage the project’s goals and deliverables.
- Schedule: Plan and track the timeline of each task.
- Budget: Estimate and control the project’s costs.
- Quality: Ensure the software meets the required standards and user needs.
- Risk: Identify potential issues and plan for their mitigation.
- Team: Assign roles, facilitate communication, and resolve team conflicts.
- Communication: Keep all stakeholders informed about the project’s progress.
- Procurement: Acquire necessary resources for the project.
- Integration: Coordinate all aspects of the project for effective collaboration.
- Stakeholder Management: Identify stakeholders and manage their expectations and involvement.
Requirements
- Elicitation: Gather and understand the needs and constraints of the stakeholders.
- Specification: Document the requirements in a clear, concise, and comprehensive manner.
- Validation: Check the requirements for feasibility, consistency, completeness, and stakeholder agreement.
- Management: Handle changes to requirements in a controlled manner throughout the project.
- Functional Requirements: Define what the system should do, such as specific features and functionalities.
- Non-Functional Requirements: Define how the system should behave, such as performance, security, and usability requirements.
- User Requirements: Understand and document the needs and expectations of the end-users.
- System Requirements: Specify what is needed from the system as a whole, including hardware and software needs.
- Software Quality Attributes: Identify and specify attributes like reliability, maintainability, portability, and scalability.
- Use Case Analysis: Use scenarios to understand how users will interact with the system.
Design
- Software Architecture: Define the high-level structure of the software and how its components interact.
- Modularity: Design the software in separate modules that can be developed and tested independently.
- Data Design: Design how data will be stored, accessed, and manipulated within the system.
- Interface Design: Define how the software components will interact with each other and with users.
- Procedural Design: Define the procedures or operations that will be used to manipulate the data.
- User Interface Design: Design the interfaces that users will interact with.
- Software Patterns: Use established design patterns to solve common design problems.
- Performance Design: Design the software to meet performance requirements, such as speed and memory usage.
- Security Design: Design the software to protect against threats and vulnerabilities.
- Error Handling and Recovery: Design how the software will handle errors and recover from failures.
Software Development for Nvidia GPU’s
- Microarchitectures: Tesla, Fermi, Kepler, Maxwell, Pascal, Volta, Turing, Ampere, Hopper
- Parallel Computing: Develop code to exploit massive parallelism in Nvidia GPUs, including parallel algorithms, models and design.
- CUDA: Develop code in Nvidia’s CUDA (Compute Unified Device Architecture) language for massively parallel computing.
- Languages: Develop code in Python, C, C++ and integrate with CUDA.
- Memory Management: Effective CPU and GPU memory management to optimize performance.
- Hardware Knowledge: Deep understanding of Nvidia GPU architectures.
- Optimization: Crucial understanding of Nvidia GPU algorithms for parallel computing and code optimization.
- Multi-GPU Programming: Distribute workloads across multiple GPUs and manage the increased complexity of multi-GPU software development.
- Mathematical Computations: Nvidia GPU algorithms often involve mathematical computations, i.e. matrix operations in machine learning.
- Nvidia Libraries: Deep knowledge of Nvidia GPU libraries, library algorithms and library API’s.
- Nvidia Toolsets: Experience with an array of Nvidia GPU tools for efficient software development.
Testing
- Test Planning: Define the strategy and plan for testing activities.
- Test Cases: Create specific scenarios to test different aspects of the software.
- Test Execution: Run the tests and record the results.
- Defect Reporting: Document any bugs or issues found during testing.
- Test Automation: Use tools to automate repetitive testing tasks.
- Functional Testing: Test the functionality of the software to ensure it works as expected.
- Non-Functional Testing: Test non-functional aspects like performance, usability, and security.
- Regression Testing: Test the software after modifications to ensure existing functionality still works.
- User Acceptance Testing: Have end-users test the software to ensure it meets their needs.
- Test Closure: Evaluate the testing process and use the information to improve future testing.
Maintenance
- Corrective Maintenance: Fix known defects and make the software work as intended.
- Adaptive Maintenance: Modify the software to keep it usable in a changed or changing environment.
- Perfective Maintenance: Improve the performance or maintainability of the software without changing its functionality.
- Preventive Maintenance: Update the software to prevent future problems.
- Software Configuration Management: Manage the versions and configurations of the software.
- Change Control Process: Manage requests for changes or additions to the software.
- Software Support: Provide help and support to users of the software.
- Performance Monitoring: Monitor the software to ensure it is performing as expected.
- Software Documentation: Update the software’s documentation to reflect changes.
- Retirement Planning: Plan for the end of the software’s life cycle.
