I'm considering moving my open-source project Flyway from Google Code to GitHub.
One of the features I really like in Google Code's Issue Tracker is the ability to vote and sort issues by the number of votes. This has allowed me to get a good feel of where current pain points lie and what the community feels needs attention or further work.
How can I achieve something similar on GitHub? Is there a way to maintain a democratic approach to Issue Tracking?
There is no built-in ability to do so. Technically speaking, you can only manage issues by
assignee
tags (called labels at github)
milestones
While you can define label systems for lots of differentation criteria like
bug/feature request/...
prio high/low/...
status verified/unverified
it is simply not possible to have something that accumulates votes. So typically you will see "+1" postings as in good old mailing lists. I've seen people using external voting systems (like Google moderator) for issues on github, but that doesn't make a good user experience either.
If you're willing to use a third-party system that integrates with GitHub, you can try GitPoll.
Related
Consider two repos, webui_repo and webservice_repo, that are two interdependent systems (the web UI and service, respectively).
As you can imagine, the webui depends on webservice, but imagine that they've grown a lot and are managed by two teams, thus a considerable amount of effort is required to get things going, and that's ok.
But sometimes one of them gets deployed and either breaks retro-compatibility or expects a feature that hasn't been deployed yet. In order to alleviate that, I thought of a dependency-check feature, based on commit keywords (similar to closing issues using keywords):
This is my commit message. Depends on: webservice_repo/commit/<commit_hash>
I've done a small research and couldn't find any existing feature that provides this. I've also tried to find out if Github provides any extension/customization to the merge process, but no answer there as well.
Any ideas?
Even though I still think this should be a GitHub's feature, I have written a small web app to provide this functionality: Pierre DeCheck
I hope it's useful to more people. Also, it's open source, start contributing already! :)
Github provides nice feature to manage feature completeness OR sprint completeness. It's called Milestones and it's really nice.
However, sometimes we need to track both completeness of the feature (e.g. "Refactoring payment systems integration") and completeness of the sprint (e.g. "Sprint week 15").
Is there any way to do so using Github issues?
GitHub does not currently allow you to assign multiple milestones to an issue. There is an issue tracking this feature request, but there seems to be little movement on it.
There's a couple of workarounds possible. The simplest one is to use Milestones to track sprints, and labels to track features. While labels do not give you the nice "X% completed" overview that Milestones do, you can quickly (single click) get an overview of all issues tagged with a label, and see how many are open vs. closed.
Another possibility is that you use Task Lists (see GitHub Markdown guide) to your advantage. Instead of having each issue belonging to a particular feature as an independent GitHub issue, you track the entire feature as a single issue, and add a Task List to the issue to track individual items. The advantage of this is that you get a nice progress bar in your issue overview, showing you feature completeness. A disadvantage is that you cannot assign individual tasks to separate developers any longer.
We currently keep our coding standard in a MSWord document under SVN.
As our standards grow / change, it's becoming an increasingly clunky beast to maintain.
Most entries currently consist of:
A succinct explanation of the guideline.
Reasoning behind the guideline.
Any extra notes.
Examples of what you should do.
Examples of what you should not to.
At the moment we use track changes within the document to keep track of pending suggestions / corrects which are periodically reviewed and then accepted / rejected.
Is there a de-facto good way of tackling maintaining a document like this?
A repository at GitHub would serve well. See example: https://github.com/airbnb/javascript - you can have discussions, track changes, accept/reject pull requests, etc.
Also it would help if you use auto-formatting tools plugged into your build process like https://golang.org/cmd/gofmt/ or https://github.com/thoughtbot/hound
I suggest you use plain text file (or HTML / some other markup file if you need some fancy formatting) under some version control system. We used Word's features for versioning and I like what Git offers much much more.
GITHUB: As an organization, if you maintain a private Github repository (not opensource, but leverage Github's strengths to maintain repository, allow distributed coding accessible to individuals within organization), you could upload your Coding Standards document to a Github repository, maintain a markdown document, which could have reviews/pull requests etc, as mentioned by Alex above
REVIEWBOARD: If your organization does not have a private Github repository, then I suggest you could choose this option, if your organization is performing code reviews through review board. ReviewBoard allows to review code by peers, maintain data of the different reviews, whether addressed, whether the version is allowed to be shipped etc. So, you could avail this feature of review board to review Coding Standards document. ReviewBoard has a feature of reviewing PDF documents. So, I guess by this option, you are maintaining a repository for CodingStandards document as well as providing an option of reviewing PDF document, which is tracked by ReviewBoard application.
Hope it helped. I guess there might be many other ways in which many companies might be doing.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 9 years ago.
Improve this question
My company has been evaluating different crm/project management solutions, hoping to find a solution to our ever increasing workload. I've found some good crm solutions, some good PM solutions, and some good helpdesks, but nothing that integrates well. It seems all the "package deals" that includes all options generally do things rather poorly.
I'm involved in some client sales, a lot of project management, and quite a lot of helpdesk queries. To get an overview of my day I need to keep track of tasks in 3 completely different systems + handle email and calendar. That's tasks/meetings scattered over 5 different places, and I don't feel like I have a good overview of my day. I use a lot of time on just pushing tasks around to make sure I dont forget anything.
What kind of solutions do people use to avoid this? Is there a good "all in one" solution out there that I've missed. Or do people use tools that integrate well with eachother? Or maybe it's my workflow that's the issue.
My team and I have been in the similar situation. We have tested Trello, Asana and many more. In my case I am working with multiple projects in parallel, where every project has different groups of people involved. And, after all the searching, Wrike appeared to be the best option.
I like it as it has a simple and clear dashboard view (with my current and overdue tasks, tasks assigned to others, etc.), Activity Stream and Gantt chart that solved my workload management issue. It also came in very handy for managing our CRM workflow, keeping all our leads and projects in one app. Well, and e-mail integration is my personal favorite (basically, it converts my e-mails into tasks, I just need to add Wrike into the e-mail’s CC and it will be transferred into the app). This, Outlook add-in and couple of more integrations helped us minimize iterations and avoid losing data. Wrike has actually become the “all-in-one” tool we’ve been searching for.
Hope, you’ll find it helpful too. Tell me how it went afterwards.
Microsoft Dynamics Crm 2011 should be able to handle all of this.
It comes with a stack of core functionality which you can then customise and extend to meet your specific requirements. It also have inbuilt integration with Outlook to handle your emails, calendars and tasks.
Client Sales: Mscrm comes with a Sales pipeline, get more information from here and make sure to watch the demo to see how it integrates with Outlook.
Helpdesk: Mscrm comes with a generic 'Customer Service' module, which you can use for helpdesk and support. Info here and demo here.
Project Management: Mscrm does'nt really have anything inbuilt for this, you would need to extend Mscrm for this, that said, Mscrm allows easy customisations (that's not to say it will do everything you want, that's not to say you wont need custom code at times and that's not say its all easy). There's some info here.
Right so that all said, as a little disclaimer: I don't work for Microsoft and I don't get anything out of you buying Mscrm (unless you happen to use my company as an IT consultancy). I also don't know how Mscrm compares to other Crm's out in the market place. However I do know that Mscrm is a very able system.
Hope this helps you to come to an informed decision.
Generally speaking:
Clients don't care about project management other than "where is my stuff?"
Clients will generally pester you through email
Something out-of-the-box is not going to 100% fit what you need (tweaking required)
Unless everything is in ONE TOOL you have no chance of reducing the data silos and the constant "jumping around" that kills productivity
IMHO, you need three projects:
Sales/CRM 'lite' = provides a simple sales pipeline/opportunity management.
Help-desk = incoming email automatically turned in tickets from customers, etc.
Tracking = for managing tasks with workflow so stuff gets done internally.
Simply link items between those three projects so people get a "connected" view of the business. Don't get hung up on Gantt charts but instead focus on managing simple lists of tasks, tickets and the like. That is what needs managing.
You also need an Outlook connector so that:
You can one-click turn a client email into a ticket inside the Help-desk project
You can see in Outlook what is assigned to you
You can see in an Outlook Calendar when items start/finish
You will probably need to find something that you can implement and tune in days not weeks.
Disclaimer: we use the EXACT same model have depicted above: Sales, Help-desk, Tracking. We build a product called Gemini in an attempt to solve this problem hence bias/opinion is inevitable.
Everyone has their favorite PM / Tracker software, and their least favorite, but this one (JIRA) worked well for a very complex and fast-paced dev shop I used to work for:
https://www.atlassian.com/software/jira/whats-new
Things to note
It's primarily a bug tracker, so workflows and issue filtering are
paramount
It can be used as a helpdesk service, through email-to-ticket feature, but requires some (non-coding) fenagling
Medium-sized developer community with many helpful plugins
Can get pricey, cheaper than most CRM solutions though
Lots of reporting features and plugins, including Gantt Agile/SCRUM/waterfall OOTB
setups
Atlassian makes it, and while their documentation and customer service aren't the best around, they're sufficient enough to get the job done when debugging, and it's a big enough company that they can be considered stable (for CYA protection when things go bad).
I personally wrangled a JIRA instance into being a PM system for 50+ projects (internal and client-facing), with 300+ users in 5-15 depts at any given time, with integrated version control features (tickets could be affected via git commit messages), and we also used it to handle inter-office requests (from printer setups to domain purchases).
In some ways we stretched it a little too far (workflows became incredible complex when too many departments had a say in the process), but in some ways we barely scratched the surface of what it could do (it's reporting features are extremely robust).
It's not always the best idea to make one tool do every job, but when push came to shove, JIRA wasn't the worst choice we could have made, and it ended up looking great to front-end/client users. It's probably a little much for a small group to use, but can handle anything from small to extra-large (1000+ users) org's.
[EDIT: forgot to mention, calendar integration (with iCal especially) was not that great when I used it, many events were either in-JIRA or out-of-JIRA (in iCal, gCal, etc) but it may have been improved in the last two years]
Consider RT. I'm a fan, and expect no material gain from this recommendation. Indeed, since the question is OT for SO I expect to lose rep.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
We use Trac as our bug tracking / development / wiki system and I was wondering if anyone has experience and uses some of the Trac Agile/Scrum plugins or functionalities? Anything you'd recommend?
Or would it be better to duplicate Trac tickets as dead-tree user story index cards and a hand-drawn burndown chart?
Note that I found a similar question here. Though it's specifically about Scrum. They recommend Agilo. Has anyone tried Agilo yet?
With a collocated team, I'd always duplicate user stories on index cards. A wall of cards is much more collaborative and simple to use than any software tool. And what's most important, it's in your face.
The same is true for a burn chart. In my experience, a software chart gets online looked at by a small number of people, and typically is a pull medium. A big, handdrawn poster (that changes regularly) gets noticed by everyone, and serves as an incubator for ad hoc discussions.
It's also quite valueable to be able to point at them during your daily scrum meeting.
This is how we use Trac for our scrum like sprints:
We use the milestones in Trac to identify sprints.
There is a default Backlog milestone where we gather all new tickets.
Before each sprint we move tickets from the backlog the current release.
On the milestone page, we can add retrospectives and other info about the sprint using wiki syntax.
So just the default Trac functionality without any plugins for now to keep it lightweight. As we get better we may add features like burndown charts or maybe switch to another tool, but we want to get the proces in place first.
Answering late, but this more of sharing my experience with Trac+Agilo so far.
To quickly answer your question, perhaps Agilo is the best option available for Agile development with Trac.
Now comes to install and usining install was just very easy. We used their latest release 0.7.3.3. It installs flawless on Trac 0.11 and Python 2.5. Don't forget to install libjpeg and python imaging library. It would be useful to note that we used virtualenv which took a made things easier.
Further usage is very simple. For wiki I kind of prefer Trac's old clean look over Agilo's customization. Other than that all things just works.
On thier mailing list I have noticed that they are planning to offer multi-project support in future. In all I recommend Agilo plugin for Trac.
Yep, I installed Agilo on our Trac installation.
Seems very cool, includes nice burndown charts.
Unfortunately I left the company where I installed it before I could get any serious usage out of it.
Installation was a pain (Ubuntu Ibex) - I documented precise steps on the Agilo Google Group.
The problem (as always) is integration into the business end of things that PMs and CEOs like to see (e.g. estimated vs actual hours). There are (as has been mentioned) other products out there that cover this off (FogBugz covers this off I believe), but I (and the team) love Trac so we worked around this.
Oh, one more thing; it looks like it introduces quite a lot of overhead (i.e. you have to spend more time in trac to get the most out of it), but like I say I didn't have an opportunity to really use it in anger.
We used Trac before with a burndown plugin then went to Redmine. We've found Redmine to be miserable for repository viewing and the issue interface. We're actually looking to move back to Trac again.
Bitten is a Trac plugin for continuous integration that can be harnessed to do automatic builds on check-in, which provides a critical part of the Agile process (rapid feedback). I haven't used any other plugins for Trac personally, so I can't comment on them. However, the native Trac functionality of milestones could be leveraged fairly easily, I suspect, to be used as iteration markers (where each milestone represents the end of an iteration). Since milestones can be used to mark a 'due date' for features already, you shouldn't need much in the way of modification to use them as such.
From there, using tickets as user stories, and tying them to milestones (I'm sure this can be done manually at worst) would give you a basic method of tracking velocity and keeping the team aware of progress (and changes that need to be made as well).
We use the Trac wiki for:
List of requirements for each feature
List of technical specs (if any) for the features
List of Releases and their features
Deployed environments, with links to all instances
There's a macro for making web requests, so we can list which version, etc. each env have
(there's a GraphViz plugin which is quite helpful for simple drawings)
There's also a ticket in the ticketing system for each "feature", for keeping a gross backlog and the current/next sprint planned.
Then we write a bunch of cards during sprint planning for each feature.
There's also a more operational side to things. We keep one person each sprint on Ops, so we have one person who's dedicated to be interrupted by people outside the team. The rest of the team can focus on delivering features.
Each bug/ops task gets a ticket, but as soon as we start working on it, it gets a card and starts moving across the board. That way it gets visibility and we don't forget to involve the testers, etc.
Scrum is pretty tactile, so I don't think it would work great to put too much stuff outside of the physical working environment. But in the end your team needs to find a balance that works.
For something completely different, the best way to do Agile Development with Trac may be to simply migrate everything to Redmine. It supports Trac's core features with some extras including multiple projects, Gantt charts, forums, DCVS, etc. though it looks like it's not completely there yet. Some good things in the pipeline.
Daniel Srb (in the comments) has a redmind agile plugin he's been working on that looks promising. You may be able to contact and see if he's planning to release it (was a long time ago).
We've had success using two products in concert in the past, Trac for tickets, xplanner for planning.
Agilo for Scrum rocks, the latest versions are using client side generated charts, so there is no dependency anymore, much easier to install :-) agile42 just release a Pro version that enriches the Agilo experience with a nice and intuitive Planning Board, very cool screencast :-)
We recently started using Scrumban.
Basically a Kanban board, with the daily stand-up meetings covering the classic Agile Scrum questions - what did you work on the previous day? what do you plan to work on today? do you have any blockers?
We do this around a physical Kanban board, it is great for visualizing the work flow and for team synergy, but we also wanted a digital form of our Kanban board to be able to double check trac usage vs. the physical board.
In search for something that would work, I found this clever post on re-creating a digital version of the Kanban board in trac.
It is very straight forward and simple, I was able to easily manipulate this approach for our work flow, and you could probably tailor it to your Agile Scrum iterative approach (or if your able to ditch the time boxed approach, give Scrumban a try).