Skip to main content

Type Conversion in Python: int(), float(), str() and bool() Explained

Have you ever entered a number into a Python program but received an error when trying to perform a calculation? This is a common problem for beginners. It often happens because the data type of a value is different from what the program expects. For example, when you use Python's input() function, the value entered by the user is returned as a string. If you want to perform mathematical calculations with that value, you may need to convert it into a numeric type first. This process is called type conversion . In this article, we will learn what type conversion is, why it is useful, how to convert values using int() , float() , str() , and bool() , and how to avoid common errors. 1. What Is Type Conversion in Python? Type conversion is the process of converting a value from one data type to another. For example, you may convert: A string into an integer. An integer into a floating-point number. A number into a string. A value into a Boolean value. Consider this example: number = ...
Post a Comment

GitHub Projects: Manage Tasks, Teams & Software Development from One Dashboard

Building a software project involves much more than writing code.

You may have:

  • Features to develop

  • Bugs to fix

  • Developers to assign

  • Deadlines to track

  • Pull Requests to review

  • Releases to prepare

  • Tasks waiting for approval

If you manage all of this using separate spreadsheets, documents, and chat messages, it can quickly become difficult to keep everything organized.

GitHub provides a solution called GitHub Projects.

GitHub Projects allows you to organize and manage work directly alongside your repositories, Issues, and Pull Requests.

In this article, you'll learn what GitHub Projects are, how they work, Projects views, boards, tables, custom fields, filters, workflows, automation, and how developers can use Projects to manage real software development.

What is GitHub Projects?

GitHub Projects is a project-management and planning feature that helps you organize GitHub work such as Issues and Pull Requests.

You can create different views of your work, including:

Board
Table
Roadmap

A simple workflow might look like:

Issue
  ↓
GitHub Project
  ↓
To Do
  ↓
In Progress
  ↓
Review
  ↓
Done

Instead of looking at hundreds of Issues individually, you can create a visual system for managing them.

GitHub Projects in Simple Words

Think of GitHub Projects as a project management board connected to your GitHub development workflow.

For example:

┌──────────────┬──────────────┬──────────────┬──────────────┐
│    TO DO     │ IN PROGRESS  │    REVIEW    │     DONE     │
├──────────────┼──────────────┼──────────────┼──────────────┤
│ Login        │ Dashboard    │ Payment      │ Homepage     │
│ Search       │ API          │ Validation   │ README       │
│ Dark Mode    │ Database     │              │              │
└──────────────┴──────────────┴──────────────┴──────────────┘

This makes it easier to understand the current state of a project.

Why Were GitHub Projects Created?

GitHub Issues are excellent for tracking individual tasks.

But imagine you have:

200 Issues
30 Pull Requests
15 Developers
5 Releases

Looking at individual Issues isn't enough to understand the overall project.

GitHub Projects provides a higher-level view.

Issues
   ↓
Projects
   ↓
Overall Development

GitHub Issues vs Projects

This is an important distinction.

Issue

An Issue represents a specific piece of work.

Fix login bug

Project

A Project organizes many pieces of work.

Version 2.0 Project

├── Login
├── Dashboard
├── Payment
├── Search
└── Documentation

A simple rule:

Issue = Individual work item

Project = Organized collection of work

Creating a GitHub Project

The exact GitHub interface can change, but the general process is:

  1. Open GitHub.

  2. Navigate to the Projects area.

  3. Create a new Project.

  4. Give the Project a name.

  5. Choose an appropriate view.

  6. Add Issues and Pull Requests.

  7. Configure fields and workflows.

For example:

Project Name:

E-Commerce Application

Then add your development tasks.

Project Views

One of the most powerful features of GitHub Projects is that the same underlying work can be viewed in different ways.

Common views include:

Table
Board
Roadmap

Each view is useful for a different purpose.

1. Table View

The table view presents work in a spreadsheet-like format.

For example:

TitleStatusPriorityAssignee
Login bugIn ProgressHighRahul
Search featureTodoMediumAman
Payment APIReviewHighPriya
Update READMEDoneLowShivam

This is useful when you want to see lots of information at once.

Why Use Table View?

Table view is useful for:

  • Planning

  • Filtering tasks

  • Reviewing assignments

  • Managing priorities

  • Updating project information

  • Working with many Issues

It is especially useful when a project contains many work items.

2. Board View

Board view is similar to a Kanban board.

For example:

TO DO
────────────
Login
Search
Dark Mode

IN PROGRESS
────────────
Dashboard
API

REVIEW
────────────
Payment

DONE
────────────
Homepage
README

You can move work through different stages.

To Do
  ↓
In Progress
  ↓
Review
  ↓
Done

What is Kanban?

Kanban is a visual method of managing work.

Work is represented as cards and moved between stages.

For example:

Backlog → Development → Testing → Completed

GitHub Projects can be configured to support this style of workflow.

3. Roadmap View

Roadmap view is useful for planning work over time.

For example:

August       September       October
|------------|---------------|------------>

Login
████████

Dashboard
      ██████████

Payment
             ███████████

Mobile App
                    █████████████

This gives a high-level view of when work is planned.

Why Roadmaps Are Useful

Roadmaps are useful for:

  • Release planning

  • Product planning

  • Major features

  • Project timelines

  • Team coordination

Instead of asking:

"What are we working on?"

you can visually see the planned work.

Adding Issues to a Project

A Project becomes useful when you add work items.

For example:

Issue #101
Fix login bug

Issue #102
Add search

Issue #103
Create dashboard

These can be added to your Project.

Then you can organize them:

Issue #101 → In Progress
Issue #102 → Todo
Issue #103 → Done

Adding Pull Requests

GitHub Projects can also include Pull Requests.

For example:

Issue #101
    ↓
Pull Request #120
    ↓
Project

This gives your team visibility into both planned work and active code changes.

Custom Fields

One of the most useful capabilities of GitHub Projects is custom fields.

You can add fields that match your team's workflow.

For example:

Status
Priority
Team
Sprint
Estimate
Release

A project could look like:

TaskStatusPriorityTeamRelease
LoginIn ProgressHighBackendv2.0
SearchTodoMediumFrontendv2.1
PaymentReviewCriticalPaymentsv2.0

Status Field

A Status field represents the current state of work.

For example:

Todo
In Progress
Review
Done

You could also create:

Backlog
Planning
Development
Testing
Released

The exact workflow depends on your team.

Priority Field

Priority helps identify what should be worked on first.

For example:

Critical
High
Medium
Low

Suppose your project has:

Payment failure → Critical
Login bug → High
Dark mode → Medium
README update → Low

Developers can quickly understand what matters most.

Assignees

Projects can show who is responsible for each work item.

For example:

Login → Rahul
Payment → Priya
Frontend → Aman
Documentation → Shivam

This creates accountability.

Iterations

Teams working in planned cycles can use iteration fields where appropriate.

For example:

Sprint 1
Sprint 2
Sprint 3
Sprint 4

A team could organize work like:

Sprint 1
├── Login
├── Registration
└── Dashboard

Sprint 2
├── Payment
├── Search
└── Notifications

This can be useful for teams following sprint-based development.

Projects and Milestones

Projects and milestones can both organize work, but they serve different purposes.

Milestone

Groups Issues around a goal or release.

Version 2.0
├── Issue #1
├── Issue #2
└── Issue #3

Project

Provides a broader workspace for planning and organizing work.

Project
├── Backlog
├── Development
├── Review
└── Done

They can be used together.

Projects and Labels

Labels categorize work.

For example:

bug
feature
documentation
security

Projects can organize that work into workflows.

For example:

Labels
  ↓
Categorize

Project
  ↓
Organize and Track

Both can work together.

Filtering Project Items

When a Project becomes large, you don't necessarily want to see everything.

Filters can help you focus on specific work.

For example:

Assignee: Rahul

could show Rahul's assigned work.

Or:

Priority: High

could focus on important tasks.

You can also filter based on other supported project fields.

Example Filter

Suppose your project contains:

100 tasks

You want only:

High priority
Backend
In Progress

A filtered view can help you focus on that subset.

This is especially useful for large teams.

Multiple Views for One Project

You don't have to create separate Projects for every way you want to look at your work.

You can create multiple views.

For example:

E-Commerce Project
│
├── Board View
├── Table View
└── Roadmap View

The same underlying work can be presented differently.

Example

Board

Todo → In Progress → Review → Done

Table

Task | Owner | Priority | Status

Roadmap

Feature → Timeline

This is one of the biggest advantages of GitHub Projects.

GitHub Projects for Students

GitHub Projects isn't only for companies.

Students can use it for personal projects.

Suppose you're creating:

Java Student Management System

Your Project could contain:

Todo
├── Login
├── Student Registration
├── Attendance

In Progress
├── Database

Done
├── README

This makes your project more organized.

GitHub Projects for Personal Projects

Even if you're working alone, Projects can help.

For example:

My Portfolio Website

Tasks:

Todo
├── Add About page
├── Add Projects section
├── Add Contact form

In Progress
├── Homepage

Done
├── Domain setup

You can visually track your progress.

GitHub Projects for Teams

Imagine a team of five developers.

Frontend
Backend
Database
Mobile
DevOps

A Project can show:

Task
 ↓
Team
 ↓
Developer
 ↓
Status
 ↓
Release

Everyone gets a shared view of the work.

Example: Software Development Project

Suppose you're developing an ecommerce website.

Your Project could look like:

TO DO
────────────────
Search
Wishlist
Reviews

IN PROGRESS
────────────────
Shopping Cart
Payment API

REVIEW
────────────────
Login

DONE
────────────────
Homepage
Registration
Product Page

Now anyone on the team can quickly understand the project's current state.

GitHub Projects and Releases

Projects can also help organize work toward releases.

For example:

Version 1.0
├── Login
├── Registration
├── Dashboard

Version 1.1
├── Search
├── Wishlist

Version 2.0
├── Payment
├── Mobile App

This provides a connection between development planning and software releases.

GitHub Projects Automation

GitHub Projects supports automation features that can reduce repetitive work.

For example:

Pull Request Opened
       ↓
Project Item
       ↓
Status → In Progress

Or:

Pull Request Merged
       ↓
Status
       ↓
Done

The exact automation available depends on your Project configuration and GitHub's current capabilities.

Why Automation Matters

Imagine a team manually updating:

Issue Status
Project Status
Pull Request Status

every time something changes.

That wastes time.

Automation can reduce repetitive project-management work.

Example Automated Workflow

A development workflow could be:

Issue Created
      ↓
Todo

Developer Starts Work
      ↓
In Progress

Pull Request Opened
      ↓
Review

Pull Request Merged
      ↓
Done

This creates a smoother workflow.

Projects and Pull Requests

A Pull Request represents a proposed code change.

Projects help track where that work fits into the overall project.

For example:

Issue #25
Fix payment bug
       ↓
Pull Request #40
       ↓
Project
       ↓
Review
       ↓
Done

This creates visibility across the entire development process.

Projects and GitHub Actions

GitHub Actions can automate development workflows.

Projects can complement these workflows.

For example:

Pull Request
     ↓
GitHub Actions
     ↓
Tests
     ↓
Build
     ↓
Project Status

This combination can provide both:

  • Automated software workflows

  • Organized project management

We'll explore GitHub Actions in detail in a later article.

GitHub Projects vs Trello

GitHub Projects and Trello can both be used for visual task management.

But they have different strengths.

FeatureGitHub ProjectsTrello
GitHub Issues integration✅Requires integration
Pull RequestsNative GitHub workflowNot native
Code-centric workflowExcellentGeneral purpose
Software developmentExcellentGood
Kanban-style boards✅✅
GitHub ecosystem integrationExcellentExternal

If your development work already lives on GitHub, Projects can keep planning close to the code.

GitHub Projects vs Spreadsheet

A spreadsheet can track:

Task
Owner
Status
Deadline

But GitHub Projects can connect those work items directly with GitHub Issues and Pull Requests.

Instead of:

Spreadsheet
     ↓
Developer
     ↓
GitHub

you can have:

GitHub Project
     ↓
Issue
     ↓
Pull Request
     ↓
Code

This reduces the gap between planning and development.

GitHub Projects for Open Source

Open-source maintainers can use Projects to organize:

Bug fixes
Features
Documentation
Community requests
Releases

For example:

Open Source Project
│
├── Backlog
├── Good First Issues
├── In Development
├── Review
└── Completed

Contributors can better understand what the project is working on.

Project Planning Workflow

A professional workflow might look like:

Idea
 ↓
Discussion
 ↓
Issue
 ↓
Project
 ↓
Assign Developer
 ↓
Development
 ↓
Pull Request
 ↓
Code Review
 ↓
Merge
 ↓
Release

Each GitHub feature has a different role.

GitHub Projects and Agile Development

Teams following Agile practices can use Projects to organize development work.

For example:

Backlog
 ↓
Sprint Planning
 ↓
Sprint
 ↓
Development
 ↓
Review
 ↓
Done

Projects can provide a visual representation of this process.

However, GitHub Projects itself does not force your team to follow one particular methodology.

Example: Sprint Board

A team could configure:

SPRINT 12

Todo
────────────
Search
Notifications

In Progress
────────────
Payment API
Dashboard

Review
────────────
Authentication

Done
────────────
Homepage

At the end of the sprint, the team can review completed and remaining work.

Project Views for Different Teams

Different teams may want different views of the same project.

Developer View

Task
Status
Assignee
Pull Request

Product View

Feature
Priority
Timeline
Release

Management View

Progress
Milestone
Risk
Timeline

Multiple Project views can help each group focus on the information they need.

Best Practices for GitHub Projects

Keep Statuses Simple

Don't create 20 workflow stages.

A simple workflow can be enough:

Todo
In Progress
Review
Done

Use Meaningful Custom Fields

Only add fields that provide useful information.

Keep Issues Updated

Projects work best when the underlying work items are accurate.

Use Filters

Create focused views for specific teams, releases, or priorities.

Automate Repetitive Tasks

Use available GitHub automation where it makes sense.

Avoid Duplicating Information

Don't maintain the same task separately in GitHub, a spreadsheet, and multiple documents unless there is a specific reason.

Common Beginner Mistakes

Creating Too Many Projects

One well-organized Project can be better than many disconnected Projects.

Too Many Columns

Keep the workflow understandable.

Not Connecting Issues

Projects become much more useful when connected to actual GitHub work items.

Ignoring Status Updates

A board is only useful if its information remains accurate.

Adding Unnecessary Fields

More fields don't automatically mean better project management.

Example Complete Project

Imagine:

Project: E-Commerce Website

Board

TODO
────────────────
Wishlist
Reviews
Search

IN PROGRESS
────────────────
Payment
Cart

REVIEW
────────────────
Login

DONE
────────────────
Homepage
Registration

Custom Fields

Priority
Team
Release
Estimate

Views

Board
Table
Roadmap

Now the same project can be understood from multiple perspectives.

GitHub Project Workflow at a Glance

                GITHUB PROJECT
                     │
        ┌────────────┼────────────┐
        ↓            ↓            ↓
      Issues       PRs        Planning
        │            │            │
        └────────────┼────────────┘
                     ↓
                 Status
                     ↓
            Development Progress
                     ↓
                  Release

Frequently Asked Questions

What is GitHub Projects?

GitHub Projects is a project-management and planning feature integrated with GitHub.

Is GitHub Projects the same as GitHub Issues?

No.

Issues track individual work, while Projects help organize and manage work at a broader level.

Can I use GitHub Projects for personal projects?

Yes.

Can Projects contain Pull Requests?

Yes.

What is a Board view?

A visual Kanban-style representation of project work.

What is Table view?

A spreadsheet-like representation of Project items.

What is Roadmap view?

A timeline-oriented view useful for planning work over time.

Can I create custom fields?

Yes, Projects supports custom fields for organizing work.

Can GitHub Projects automate tasks?

Yes, GitHub provides automation capabilities that can reduce repetitive project-management work.

Are GitHub Projects useful for open-source projects?

Yes. They can help maintainers organize Issues, Pull Requests, features, bugs, and release planning.

Summary

GitHub Projects provides a powerful way to organize software development work directly inside GitHub.

You can use it to:

  • Manage Issues

  • Track Pull Requests

  • Create Kanban-style boards

  • Create tables

  • Plan work on roadmaps

  • Add custom fields

  • Assign tasks

  • Track priorities

  • Filter work

  • Organize releases

  • Automate repetitive workflows

The basic concept is:

Issue
   ↓
Project
   ↓
Status
   ↓
Development
   ↓
Pull Request
   ↓
Done

GitHub Projects becomes especially powerful when combined with Issues, Pull Requests, Discussions, Milestones, GitHub Actions, and Releases.

Labels:

Comments

Post a Comment

Popular posts from this blog

Understanding Comments in Java: A Beginner’s Guide

When learning Java programming, one of the first concepts you’ll come across is comments . Comments may not affect how a program runs, but they play a crucial role in making code more understandable, readable, and maintainable. Let’s dive deeper into what comments are, why they’re important, and the different types of comments in Java. What are Comments in Java? A comment in Java is a piece of text written within a program that is ignored by the compiler . In other words, comments are notes for humans, not instructions for machines. They help developers explain the purpose of code, describe logic, or temporarily disable certain lines of code without deleting them. Why are Comments Important? 📌 Readability – Comments make code easier to understand for you and others. 📌 Maintenance – When you revisit your code after months, comments remind you what you were doing. 📌 Collaboration – In team projects, comments explain code to fellow developers. 📌 Debugging – You c...
Post a Comment
Read more

Java Program to Check Voting Eligibility

In this program, we’ll take the user’s age as input and check whether the person is eligible to vote or not. In India, the minimum age required to vote is 18 years . 💻 Program Code // Java Program to Check Voting Eligibility import java.util.Scanner; public class VotingEligibility { public static void main(String[] args) { // Create Scanner object to take input from user Scanner sc = new Scanner(System.in); // Ask user to enter age System.out.print("Enter your age: "); int age = sc.nextInt(); // Check eligibility if (age >= 18) { System.out.println("You are eligible to vote."); } else { System.out.println("You are not eligible to vote yet."); System.out.println("You can vote after " + (18 - age) + " year(s)."); } sc.close(); // Close the scanner } } 🧠 Explanation import java.util.Scanner; → Imp...
Post a Comment
Read more

Java Program to Calculate Total Marks and Average of Five Subjects

💡 Program Explanation In this program: The user will input marks of five subjects . The program will calculate the total marks and average . It will then display both results clearly. 🧑‍💻 Java Code: // Java Program to Calculate Total Marks and Average of Five Subjects import java.util.Scanner; // Importing Scanner class for user input public class TotalAndAverage { public static void main(String[] args) { // Creating Scanner object to take input from user Scanner sc = new Scanner(System.in); // Declaring variables for five subjects double subject1, subject2, subject3, subject4, subject5; // Taking marks input for each subject System.out.print("Enter marks of Subject 1: "); subject1 = sc.nextDouble(); System.out.print("Enter marks of Subject 2: "); subject2 = sc.nextDouble(); System.out.print("Enter marks of Subject 3: "); subject3 = sc.nextDo...
Post a Comment
Read more