dtxe/dsi_git_assignment

Load, analyze, and visualize TTC bus delay data

dsi_git_assignment's Issues

Necessary Details of an Issue

An issue should have a concise title, a detailed description of the issue, a list of steps to reproduce the issue, information about the environment in which the bug was observed, any screenshots (visuals tremendously aid in finding problems), and a copied and pasted text of the bug message output itself - this step will help the developer pinpoint the exact location of the bug.

GitHub Issue or bug reporting

What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

While reporting a bug or issue. Following items should be considered while writing a message :-
1.Provide the contex regarding issue such as the function/section of code where the issue has occured.
2.Input parameter to code, expected output and result we are getting at present.
3.If possible share the impact of issue on other code/section.

Such information will developer to better understand the issue and fix them.

DANIEL SIMATUPANG: What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

Crafting an effective bug report is crucial for the swift resolution of software or application issues. A well-constructed report equips developers with the necessary details to identify, replicate, and resolve problems efficiently. Here are essential steps and recommendations to guide you in creating a clear and actionable bug report:

1. Title Clarity:

• Ensure the title succinctly describes the issue.
• A specific title should convey the nature or location of the problem.

2. Detailed Environment Information:

• Specify the software version, operating system, browser, or device in use.
• Include relevant configuration settings for a comprehensive understanding.

3. Steps to Reproduce:

• Provide step-by-step instructions on how to replicate the issue.
• Be precise, including all necessary actions, clicks, or inputs.

4. Expected and Actual Results:

• Clearly articulate what was expected to happen.
• Describe the actual outcome, incorporating any encountered error messages.

5. Include Visual Media:

• Attach screenshots, images, or videos that visually represent the issue.
• Visual aids are invaluable for understanding complex problems.

6. Additional Context:

• Mention any unusual circumstances or pertinent background information.
• Include details about the frequency of the issue (always, occasionally, etc.).

7. Check for Duplicates:

• Before submitting a report, search existing bug databases.
• Avoid redundancy by ensuring the issue hasn't been reported; if it has, consider adding observations or upvoting the existing report.

8. Use Standardized Formats:

• If your organization or project employs a specific bug report template, adhere to it.
• Consistency in reporting aids in streamlining the debugging process.

9. Maintain Courtesy and Professionalism:

• Keep a respectful tone in your report.
• Acknowledge that developers and support teams are working to resolve the issue.

10. Test and Verify:

• After the issue is fixed, conduct testing to confirm resolution.
• Provide feedback on the resolution to complete the communication loop.

Adhering to these guidelines enhances the effectiveness of bug reports and contributes to a more efficient debugging and resolution process.

GIT Assignment | key items that should be included in a GitHub Issue or bug | Chimaobi Osuegbu

When creating a GitHub Issue or bug report, it's important to include the following key items to help developers diagnose and fix the bug effectively:

1. Title and Description: Provide a clear and concise title that summarizes the issue. In the description, explain the problem in detail, including any error messages or unexpected behavior observed.
2. Steps to Reproduce: Outline the exact steps required to reproduce the bug. This helps developers recreate the issue and narrow down the cause.
3. Expected and Actual Behavior: Describe what you expected to happen and what actually occurred. This comparison assists developers in understanding the discrepancy.
4. Relevant Context: Include any relevant information about the environment, such as the operating system, browser, or software version. Also, mention any specific configurations or settings that might be related to the issue.
5. Logs and Screenshots: If applicable, attach relevant logs, console output, or screenshots that provide additional context or error messages related to the bug.
6. Attempted Solutions: Explain any previous attempts you made to solve the issue. This informs developers of what has already been tried and helps prevent redundant efforts.
7. Additional Information: If there is any other useful information related to the bug, such as related issues, related code snippets, or any insights gained during investigation, include them as well.

Luiz Gustavo - Assignment Short Answer

Key Items for issues like Bug Report or Feature:

Bug Report:

• Context: describe what are you trying to do overall?

• Reproducible example:
  • include enough code and a sample dataset to reproduce the error;
  • describe what was the behavior of the code;
  • describe what is the expected behavior of the code;
  • includes screenshots, error messages, and debugging logs.

Feature requests:

• Overview: Describe the feature
• Scenarios:
  • provide user stories of how this feature could be used
  • provide a mockup of the feature you’re envisioning
• Existingworkflow:
  • describe what you’re currently doing without this feature

Answer to: What makes a well written issue?

Types of issues: Bug Fixes and Feature Requests

Both of these require context

Bug Fixes:

Context: What is it that is being done overall?
Reproducible example:

• Include code and dataset (maybe synthesised data in case it is sensitive) to reproduce the issue.
• Include the behaviour you expect
• Include how the code behaved
• include screenshots, error messages, and debugging logs!

Feature Requests

• Overview: Describe the feature
• Scenarios:

1. provide user stories of how this feature could be used
2. provide a mock up of the feature you’re envisioning

• Existing workflow:
• describe what you’re currently doing without this feature

Ahmad_Hasan_GITAssignment1_Issue

Criteria for a good bug report:

1. OS/Browser version
2. App version
3. Date of issue
4. Steps to reproduce
5. Actual result
6. Expected result (screenshot or recording)

Jagannathan_PrasannaKumar_GITAssignment1_Issue

Key items of a bug report required for a developer to debug or fix an issue

Software version error is happening
Steps to reproduce the error
environment such as OS, browser name and version
Screenshot of the error

Key Items of a GitHub Issue or Bug Report

Creating a comprehensive GitHub issue or bug report is crucial for developers to understand, reproduce, and ultimately fix the reported bug efficiently. Here are the key items to include:

• Title: The descriptive title conveys the issue.
• Description: Provide a detailed description of the problem. Include steps to reproduce the issue. State what you expected to happen and what happened.
• Environment: Specify the operating system (OS) and version. Provide details about the browser (if web-related) or application version.
• Screenshots or Recordings: Include visuals to help developers understand the problem.
• Error Messages: Include any error messages encountered. Share stack traces if available.
• Logs: If applicable, attach relevant log files. Include the timestamp of when the issue occurred.
• Versions: Specify the software/library/framework version.
• Reproducibility: Clearly outline the steps to reproduce the issue.

Answer to Git Assignment

For a developer to diagnose and fix a bug, the GitHub Issue or bug report should include the three basic components: what you did, what happened, and what you expected to happen. The Issue or bug report should provide the context (what you are trying to achieve and how) as well as a reproducible example (enough code or dataset sample to reproduce the error, the current and expected outcome, along with supporting screenshots, error messages or debugging logs).

Git Assignment - Short answer

Question: What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?
Submit your short answer as a GitHub issue in this repo https://github.com/dtxe/DSI_git_assignment.

1. Title/Bug ID: The title should contain a brief explanation of the bug.
2. Environment: Which particular environment bug can appear.
3. Steps to Reproduce a Bug: Number the steps clearly from first to last so that the developers can quickly and precisely follow them to see the bug for themselves.
4. Expected Result: This part of the Bug Report details how the software is expected to work in the specified circumstance.
5. Actual Result: Detail what the bug is actually doing and how it is a distortion of the expected result
6. Visual Proof of Bug: Screenshots and videos of log files must be provided in order to show the existence of the bug.
7. Analysis of the cause of the issue
8. Bug Severity: Every bug must be assigned a level of severity and priority. This exposes the extent to which the defect impacts the system, which determines how quickly it must be corrected.

Git Assignment -PANWALA MANTHAN

Question: What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?
Answer: The key items should be title, short description, environment, screenshots or the recordings of the reproduction of the issue, expected and current behavior, additional relevant context and error messages. This will help developer to understand and fix the bug.

Bug_Hussam_Tulimat

When creating a GitHub Issue or bug report, include the following key items for developers:

Title:

Concise summary of the issue.
Description:

Detailed explanation of the problem or feature request.
Steps to Reproduce:

Clear steps to recreate the issue.
Environment Details:

Operating system, browser, or relevant software versions.
Screenshots or Code Snippets:

Visual aids for better understanding.
Expected vs. Actual Behavior:

Clearly state expected outcome versus observed result.
Reproducibility:

Indicate if the issue is consistent or sporadic.
Logs and Error Messages:

Include relevant logs or error messages.
Version Information:

Specify the version of the software or application.
Labels:

Add appropriate labels for categorization.

Kaddoura_Bashier Key Issue Items

• title
• description - bug fix, feature requesst, or security vulnerability
• add assignees, add it to a project, set milestones, add labels

Short answer for git assignment

Some of the key items that should be included in a GitHub Issue or bug report include:

1. Clearly describe the problem that one is having, while providing the necessary information regarding the environment the issue is taking place (e.g., the issue occurred while updating versions XXX).

2. Since GitHub is a community, asking for help is important- especially asking for feedback from specific people who may have an idea. Therefore, adding code errors or screenshots of the problem may help the community assist one faster.

3. Additionally, when writing the issue, it is important to keep the message clear and concise, and that titles be short and descriptive.

NMM Unable to change load order Bug

Description:
There are no arrow buttons to change the load order. You can't drag and drop them either. Also there are no numbers for the load order.

NMM Version: 0.86.0

Mods:
Baldur's Gate 3 No more clothes for females + NPC private parts - bg3_npc_f_private_parts_2.0.3.7z
https://www.loverslab.com/topic/216228-baldurs-gate-3-no-more-clothes-for-females-npc-private-parts/

4X Carry Weight - 4XCarryWeight-261-1-01-1635519690.zip
<( No Longer Visible )>

Arcane Rings-112-1-6-1646277424.zip
https://www.nexusmods.com/baldursgate3/mods/112

BasketEquipmentNSFW-97-1-1-5-1703449798.zip
https://www.nexusmods.com/baldursgate3/mods/97

BonAppetit-337-1-0-1657303719.zip
https://www.nexusmods.com/baldursgate3/mods/337

Padme's Character Creation Added Colours - CCAddedColours-115-2-3-1619881072.zip
<( No Longer Visible )>

Community Library-1333-2-2-4-0-1706656812.zip
https://www.nexusmods.com/baldursgate3/mods/1333

Compatibility Framework-1933-2-6-3-11-1706165364.zip
https://www.nexusmods.com/baldursgate3/mods/1933

Crispy Map - Double Resolution of World Map - CrispyMap-2-1-0-0-1602892473.7z
<( No Longer Visible )>

No More Dirt And Blood - Slower and Faster Options - Disabled Dirt And Blood-344-1-1657935631.rar
https://www.nexusmods.com/baldursgate3/mods/344?tab=description

Eldritch Blast Extreme Knockback - Eldritch Blast Loose Files-78-1-0-1604256611.zip
https://www.nexusmods.com/baldursgate3/mods/78

Enhanced Nude Bodies - Humans Elves Half-Elves Drows (Normal)-652-1-1-1691496592.7z
https://www.nexusmods.com/baldursgate3/mods/652

ImprovedUI ReleaseReady - ImprovedUI-366-3-17-1704833332.zip
https://www.nexusmods.com/baldursgate3/mods/

ImprovedUI ReleaseReady - ImprovedUI Assets-366-3-17-3-1-1705780988.zip
https://www.nexusmods.com/baldursgate3/mods/366?tab=files

Baldur's Gate 3 Mod Fixer - Mod Fixer-141-1-0-1692715645.zip
https://www.nexusmods.com/baldursgate3/mods/141

5e Monster Slayer - Ranger Subclasss (Plus New Spells) - MonsterSlayer5e.zip-5842-2-5-0-1705948736.zip
https://www.nexusmods.com/baldursgate3/mods/5842

More Vampire Bites - MoreVampireBites.pak-18-2-2-1603652031.zip
https://www.nexusmods.com/baldursgate3/mods/18

Native Mod Loader - NativeModLoader-944-1-1692533783.zip
https://www.nexusmods.com/baldursgate3/mods/944

Nudity - Nudity.zip-46-1-0-0-1603659037.zip
https://www.nexusmods.com/baldursgate3/mods/46

Raven Queen's Chosen - Shadar-Kai - Shadar-Kai-1305-2-3-0-1693612103.zip
https://www.nexusmods.com/baldursgate3/mods/1305

Better Thorn Whip Damage - ThornWhipDamageUp-240-1-1629582279.zip
https://www.nexusmods.com/baldursgate3/mods/240?tab=description

Picture Showing Load Order and lack of arrows or numbers:

Short answer

What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

Title, environment information, steps to reproduce the issue, expected behaviour, visuals of the issue, analysis of the cause of the issue.

What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

A well-documented bug report should contain the following elements:
1. Title: A concise and descriptive title that summarizes the issue.
2. Description: A detailed explanation of the bug, including reproducing the bug, what happened wrong etc.
3. Environment: Any information regarding the system (Windows, Mac), browser/hardware/software used
4. Supporting evidence: Any screenshot or other supporting media files
5. Error Messages : Error message received; details of log

Key items should be included in a GitHub Issue

#What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

Context

The assignment wants us to answer here, instead of a plain old boring Google Doc

Answer

A Github Issue is to have context, reproducible examples and include screenshots/error messages.
Some reproducible examples include:

• Screenshots and output
• Sample of data and code
• Description of behaviour (issue) and the expected outcome

Issue post about issue posts

An issue post should be concise, yet descriptive. It should effectively communicate what the issue is, and, if possible, the contributor's thoughts on how to resolve the issue. If the issue concerns a bug in code, post could include a reproducible example that illustrates what the contributor thinks the code should do, and how the code is currently behaving.

What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

1. Describe the bug: be clear and concise.
2. Reproduce the behaviour and take steps to reproduce the bug/error (e.g. a, "Click this", "Scroll to ax function", "Go to step 4"...etc.)
3. Expected behaviour: have a concise description of what you expect to happen with the bug or error.
4. Add screenshots to explain or show/highlight the bug.

Git Assignment - Short Answer | Farzaneh Hashemi

Bug Reports:
A well-written issue includes clear context, reproducible examples, and detailed descriptions for bugs.

Feature Requests:
For feature requests, it encompasses an overview, user scenarios, a mockup, and details about the existing workflow.

Git Assignment - short answer to Q1

Q: What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

• Clear context that explains what i am trying to do.
• provide reproducible example: such as code, sample dataset, to reproduce the error. explain how the code behaves vs the expected behaviour. include screenshots, error messages, and debugging logs.
• includes feature requests that describes teh feature, provides scenarios, describes existing workflow.
  Ahmad Al-Musa

Short answer to git assignment

In a bug report, provide

1. the context for what you are trying to accomplish, if applicable, give an example of what the output would like to see if there were no bugs
2. example code that results in the error, error messages, behaviour of the code that is considered as error

MENGYI (MERYL) FANG answer to assignment

The goal is to give out a reproducible example.
To achieve that, one can include code and a sample dataset for others to reproduce the error in the github issue.
One should also explain the current outcome of the code and the expected outcome of this code.
To make the issue clearer, one should also include screenshots, error messages and logging details in the issue.

Git Assignment - Grebenisan, Sonia - Short Answer

Question: What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

Answer:

• Context: Where is the bug happening? What were your trying to do when you found the bug?
• Reproducible example:
  • Include the steps needed to reproduce the error, along with the required code, sample data, etc.
  • What happened (actual behaviour)?
  • What was supposed to happen (expected behaviour)?
  • Supporting artifacts (screenshots, error messages, debugging longs)
    

SMITH_KEATON_Git_Assignment_short_answer

A well-written GitHub Issue or bug report will provide a clear and concise summary of what you are trying to accomplish and a reproduceable result; specifically what happened and what you expected to happen. The reproduceable result should include any relevant code snippets, datasets, or other files required for the result and any error logs or messages that are corresponding with the execution of your code.

If a reviewing-developer can fully understand what you were trying to do, what you ultimately did, and what happened afterwards, then they can easily diagnose and fix the bugs within your code!

Short Answer for Git Assignment

What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

1. Title: A brief, descriptive title to summarize the issue or bug.
2. Environment Information: the name and version of operating system, browser and software bacause sometimes they may be the source of an issue.
3. Steps to Reproduce: a clear and step-by-step instruction to reproduce the issue. Mention if the issue occurs consistently or intermittently.
4. Expected Behavior: what you expect to happen
5. Actual Behavior: what actually happens, including error messages and logs
6. Screenshots/GIFs/Videos: Visual evidence of the issue, especially for some complex issues that are hard to describe in words
7. Impact of the Issue: Explain how the issue affects your project or workflow.
8. Possible Causes: possible hypothesis about the cause

Git Assignment - Vaziri, Sohrab - Short Answer

1. Title

A clear brief description of what the issue is and where it occurs.

2. Context

Showing the steps that led you to get the bug, including your code, input and data source. Comparing the expected behaviour vs. the actual behaviour.

3. Error message or Log:

Include any error message, or log file associated with the issue.

4. Supporting artifacts

Screenshots, error messages and debugging logs

Maria Semeniuk Key Items to Include in GitHub Issue, Git Assignment 1

A GitHub issue can have a title, description of the issue, specific collaborators, labels etc.
The title should describe and convey the issue quickly. The description explains the purpose of the issue and how to potentially resolve it.
If it's a bug fix, include a reprex. A reprex is a REPRoducible EXample. It contains the code to reproduce just the error. It only includes what is related to the issue. You can include a minimal dataset to demo the problem. Also it must include the classes, and packages, which are placed at the top.
Other things to include is details about the issues you are facing, comments that will clarify the error, what has been attempted to fix the error, including pages to StackOverflow articles that have been viewed.

If the issue is big, it is possible to break the task down into smaller pieces, by creating task lists, by creating square brackets and marking it complete by using an [x]. Issues can be linked to previous issues by using numbers or a URL.

File annotation can help resolve issues if its is known where the issue is. “git blame” shows us when code was introduced and by whom, line by line. “git bisect” can help get the identify of the commit that introduced the issue.

Git Assignment | Short Answer | GitHub Issue or bug report key items

Followings are the most key items that your report should have:

1- Clear and concise Title
a brief description of what the bug is, and where it occurs.

2- Short Summary
This is in case your description at the title section is not enough. This might a short summary to include additional items that your teammate will need (i.e date, time, and specific items triggered the bug )

3-What is causing the bug?
This should show steps that led you to get the bug and what was your code, input, data source, and any configuration relevant to the issue.

4- Error message or Log:
Include any error message, or log file associated with the issue.

5-Additional Information:
Any other details need to be added such as expected behavior, screenshots, previous change request id, or similar bugfix id.

Items that should be included in a GitHub Issue - Git assignment - KUMAR AMIT

When reporting a bug or issue on GitHub, it's important to provide as much information as possible to help the developer understand and reproduce the problem. Here are some key items that should be included in a GitHub issue or bug report:

1. Title: A clear and concise title that summarizes the issue. The title should be such that by reading these few words, the developer understands the context of the issue.

2. Steps to Reproduce: Detailed steps on how to reproduce the bug. This should be as specific as possible, including any relevant input data or user actions.

3. Expected Behavior: A description of what you expected to happen when you followed the steps to reproduce.

4. Actual Behavior: A description of what actually happened. Include any error messages or screenshots if applicable.

5. Environment: Information about the environment in which the bug was encountered, such as:

   • Operating system (Mac/Windows/Linux) and version.
   • Browser and version (if applicable).
   • Version of the software or library.
   • Any other relevant software or hardware configurations.

6. Reproducibility: How consistently the bug can be reproduced. Is it always reproducible, or does it happen intermittently?. If possible (and applicable) include a dockerfile which will create a docker image and the bug can be reproduced in the container. Sometimes it saves considerable amount of time helping the developer reproduce the error and use the same docker container to even fix the problem as this is a isolated environment.

7. Frequency: How often does the bug occur?

8. Impact & Priority/Severity: What is the impact of the bug? Is it a minor inconvenience, or does it prevent certain features from working? Indicate the impact of the bug on the system or users.

9. Possible Solution: If you have an idea of how the bug could be fixed, you can include that here. However, this is not always necessary.

10. Related Issues: If there are any other issues that are related to this one, link to them.

11. Assigned Developer: Assign the bug to a specific developer or team responsible for fixing it.

12. Labels: Use labels to categorize the issue (e.g., bug, enhancement, feature request) for easier tracking and prioritization.

13. Additional Context: Any other information that might be relevant to the bug, such as whether it was introduced in a recent update, or if it's happening for multiple users.

Delaney, Andre: What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

A comprehensive GitHub issue or bug report should include a concise title, detailed steps to reproduce, environment specifics, version information, reproducibility details, visual aids like screenshots, relevant code samples, error logs, a comparison of expected vs. actual behavior, and any additional context.

What Key items should be included in a GitHub issue or bug report?

Creating a detailed GitHub issue or bug report helps developers diagnose and fix the bug efficiently, the key items that should be included are the following:

1. Title of the issue
2. Description of the issue
3. Expected behavior of the issue
4. Actual behavior of the issue
5. Environment where the bug occurred
6. Screenshot or recording illustrating the issue
7. Error message logs associated with the issue
8. Reproducibility of the issue
9. Assigned Labels to categorize the issue for the task prioritization

The above key items in the GitHub issue or key report, the developers will understand, diagnose, and fix the bug effectively.

Truong_Jimmy_GITAssignment1_Issue

Issues should include what is the issue and how it can be fixed

Short answer - Git assignment - Nihar Dhanani

A bug report should include a description of the issue and details on the step at which the issue occurs, the expected behavior, and all logs, errors, and screenshots that can assist the developer in identifying and resolving the issue. Additionally, include a sample dataset and code to help reproduction of the issue.

Assignment 1 Issue

What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

A: When creating a github issue, you should write a few key things to ensure the usefulness of the issue report
You should explain what the issue is and what it is for
You should explain steps that need to be taken to reproduce the error
Explain the behaviour of the issue as well as the expected behaviour
Include screenshots, videos, error logs, etc. that will help
Indicate any other important information that could be helpful such as frequency of issues, version history, or any previously attempted solutions

Git Assignment - Short Answer - Ka Ho (Gerald)

Git Assignment - Short Answer - Ka Ho (Gerald)

What key items should be included in a GitHub Issue or bug report to enable a developer to diagnose and fix the bug?

From page 14, 15 of Working in software teams lecture slides

Bug reports

• Context: what are you trying to do overall?
• Reproducible example:
  • include enough code and a sample dataset to reproduce the error
  • what was the behaviour of the code?
  • what is the expected behaviour of the code?
  • include screenshots, error messages, and debugging logs!

Feature requests

• Overview: Describe the feature
• Scenarios:
  • provide user stories of how this feature could be used
  • provide a mockup of the feature you’re envisioning
    *Existing workflow:
  • Describe what you’re currently doing without this feature

My Addition:
Bug reports

• If the bug is user facing, what is the sequence of actions takens by the user when the bug occurs.
• Includes the runtime enviornment information, such as Operating System and its version and also the software langauge and the version used.
• If it is a software package, provide the version of the software and software library versions if applicable.

Feature requests

• Describe the problem that the feature being requested is trying to solve.
• Describe the improvement(s), such as software performance increase, efficiency increase for the user, or usability improvements etc, of the proposed feature compare to what is being done now.