Writing unit tests also requires making (a small) php program to call out to them. And from what I've seen, it only supports them locally, and not through another system. There is a post-commit review system, but it has less features, and is based only on commits.
But after looking around, there really wasn't much else that fulfilled the project-management aspects as well as code-review.
About the unit tests: indeed, out-of-the-box Phabricator only supports running them locally (you can configure the unit engine to run every time a piece of code is been send into review). Luckily, it's not that hard to hook into the event engine (https://secure.phabricator.com/book/phabricator/article/even...) to, for example, trigger your CI-server to run the test suite for a specific revision.
Also, Phabricator is still being developed actively. There are a bunch of alpha and beta applications which will only make it more powerful (for example: DryDock and Harbormaster, which will ease the work for automatic builds: http://www.guywarner.com/2014/05/integrating-jenkins-and-pha...)
In my opinion, Phabricator is one of the most powerful tools around for doing code reviews and effective collaboration management. Even with the large amount of beta applications (which are promising in many cases) the decision for us was easy to make.
Atlassian is expensive and only supports GIT, but the UI for VCS is way better (as is the Jenkins integration).
I've used trac, redmine, bugzilla, github/github enterprise, over the last ~10 years, and taken across the whole feature set, Phabricator outshines all of them. All the integrations across the product suite are nice, and the arc tool is really convenient once you get used to its quirks.
It's not the simplest thing in the world, but if you have a bigger shop with some nontrivial workflows, lots of projects, lots of teams, blocking reviews, mandatory security reviews, etc... Phabricator is a great way to wrangle it.
It comes with git and svn for source control, built-in tracking technology (big difference with redmine/jira, anyone can customize models & workflows), code review with gerrit, agile dashboard for scrum (kanban on going). Last but not least, it does scale quite well (10k users, 200k tickets, TB of git repo, ...)
Full disclosure: I'm dev on that very tool.
I find the information on your download page (https://www.tuleap.org/try-and-go) a bit confusing. What do you charge for? I need to know that up-front before investing my time... There are many products which are "free" until you need some (basic) functionality.
Also, you might want to check spelling on that (and probably other) page(s), but I don't personally mind that. :)
Tuleap is 100% libre and open source, you don't have to pay anything to use it. All the things you see on tuleap.org are immediatly available and usable without "freemium" or "open core" principle.
My company (Enalean) does have a business around Tuleap but it's service (SLA, support & co) as well as crowd-fund developments (https://www.enalean.com/en/product-services/open-roadmap)
> There is no differences between an “evaluation” and an “enterprise” version. We want you to experience the full power of the Tuleap software. Just follow the instructions to install your instance.
The way I understood it there are two versions, "enterprise" and "evaluation", and there is no difference between them (well, except for probably price, support and maybe some other hidden goodies). So next thing I tried to find info on this "enterprise" version, and could find none. :)
I would suggest you word it a bit differently... Your answer is much better at conveying the business model than the current page.
Thanks for the info, will try it out. Good luck!
anyway Thanks for sharing. :)
It's a bit better when you look at it live but the road is long. However, the on going work start on strong bases, for instance for Kanban.
I've been Jira user / Jira consultant for some time (around 3.x - 4.x versions). And I loved the tool then. I don't have the same sentiment any more and mostly find it bloated.
At the moment I'm daily Redmine and YouTrack user and find both of them much more superior.
Personally I think YT is one of the most user friendly tools out there, but I also find it quite limited and lacking (especially in regards to reporting and time management). However it seems it's being addressed with 6.x version (it's still not at the point I would like it to be, but hopefully the trend will continue).
At the moment I don't see any viable and full-featured alternatives to Redmine frankly, which is disappointing. I like the tool, however it could be more user friendly (modern) and easier to maintain (at least for non Ruby guy). I'm considering to give a OpenProject a trial demo someday, maybe things are better there (basically it's another Redmine fork).
Regarding Redmine performance - yes it could be better. However it my experience it does scale quite decently (e.g. Jira used to have major problems with it, please bear in mind my experience with the tool is ~3 years old, hopefully it's somewhere addressed currently). In one of our Redmine setups we have around 41k issues and we do not experience any major problems with it.
Actually, a colleague of mine was asking me what services I could recommend for his new venture and all I was able to come up at the time was:
- Want to manage it yourself? Use Redmine on DigitalOcean
- SaaS?, then Planio will get you covered.
I'm not affiliated to them.
This is all out of the box stuff you get with phabricator. It does those bits exceptionally well. The niceties you get with redmine, such as referencing commits or issues and autoclosing them on code push also exists with phabricator.
Think of phabricator as a more meme friendly superset of redmine.
Compared to GitHub, it has really been night and day.
Phabricator also has other niceties like syntax highlighting within diffs, two-column diffs (which admittedly GitHub added about a month ago), and a solid command-line tool ("arc") for sending off reviews, etc.
* The review dashboard already shows all the reviews you're involved, but not yet which ones require action. This feature is coming soon -- I have all the data, just need to add some code to massage and display it appropriately.
Even in Phabricator, though, when you have multiple reviewers only one has to accept for it to be accepted. Oftentimes it is _more_ confusing to have multiple reviewers because you don't know who should have the final say.
Github has Hub (https://github.com/github/hub) which is as powerful, if not more so, than arc.
The commenting system is a matter of preference, but having forgotten to "Clowncopterize" (a great demonstration of the professionalism of those who hack on Phabricator) comments, and given that they thread in email, it hasn't been a problem for me. Though I understand where you're coming from.
Yeah, this depends on workflow. We generally send every piece of code to two reviewers but just wait for either one to accept, unless there's a particular reason that both should look at the review. This works well for us but I can see how it wouldn't work as well for people with other processes.
> The commenting system is a matter of preference, but having forgotten to "Clowncopterize" (a great demonstration of the professionalism of those who hack on Phabricator) comments, and given that they thread in email, it hasn't been a problem for me. Though I understand where you're coming from.
Yes, Phabricator's isn't perfect but it's the best of the ones I've tried, especially if everyone using it is familiar with the tool and uses it frequently (that is, you might forget to Clowncopterize once or twice ever, but then you'll know for the future). I used to use Kiln (http://www.fogcreek.com/kiln/) which had a different approach for emails – they essentially debounce emails to have a half-hour delay and coalesce any emails within that timeframe together, so you get fewer emails but don't need to submit the collection of comments explicitly. Having tried all three choices, I'd say that they're all painful in different ways and I personally prefer Phabricator's approach.
For this Gerrit does offer the possibility to fully customize the approval process. It's a bit freaking odd at start because it relies on Prolog  but it's the way to tailor the tool to your process
Phabricator allows "blocking reviewers", meaning that those reviewers must. There can be any number of blocking reviewers. These reviewers can be groups or individuals. For example, you could require someone from the "Security" group to accept every revision.
Particularly, if you have a back-and-forth of changes on a PR, the inline comments that relate to lines that haven't changed stick around (and references to no longer connected comments are available in the UI). I find this huge for progressively dealing with things. And it does this whether you've force pushed a rebased cleanup or just capped another change onto the PR's branch.
And then there's the way phabricator manipulates your commit messages in rather elaborate ways that are often confusing or frustrating. It also shows that the authors don't have a lot of respect for the idea of using merge bubbles over squashing commits, and I much prefer bubbles. And because of using merge bubbles primarily, github can tell when you merge a PR even if you don't use its tools to do it.
And while I like the ability to batch comments, I don't like that it makes you always batch them. Sometimes I really only have one thing to say and it's way too easy to forget to submit.
Likewise I like the ability to do pre-review tests, but for a large codebase I also really love the commit-hook UI cycle of github's integrations with stuff like travis and circleci, because a lot of the things I've worked on in the last couple of years have full compile+test cycles in the 10s of minute ranges.
Two column layout, the batch commenting, pre-review-tests, and the code highlighting are all great. But I really prefer tools that really strongly integrate with git. I'm not really interested in vcs portability at this point.
I often wonder how many people who have really strongly negative opinions of GH PR workflows have been forced to use it with full forks instead of a shared repository. Honestly, github forks are terrible for anything but casual submission of open source patches (and even there I think there'd be better ways). I've seen people try to use them for more serious stuff and it never goes well.
When creating a topic branch and you "arc land", it will only put that nasty phabricator formatted commit message in the merge commit that merged the topic branch into the master/develop branch. When you just submit a review against the branch you want to land to, you simply git push, and the review message doesn't go to the repo.
This gives us the best of both in that phabricator doesn't overwrite our commit messages, or rebase squash things, but we get the phabricator metadata in the repo when we want it.
I'd still rather be using PRs though.
The only downside is that it doesn't allow you to do code review via git pull request. It originally was just SVN, but now has git and hg support, and it uses the same code-review tool for all of them, so it's a bit less git-centric than github.
That being said, they have a command line tool for submitting pre-push code reviews that is really really nice. I haven't figured out a way to easily do a github pull-request from the command line (though I'm sure there's a tool to do ti somewhere).
But Phabricator's power is in the whole being greater than the sum of the parts. As a unified ecosystem we've found huge power in our code reviews living next to our wiki living next to our user stories living next to our wireframes (pholio).
And yes -- even the business, operations, and account management departments are using it now too!
Will check this one soon.
Incidentally, arc offers some cool command line features: https://secure.phabricator.com/book/phabricator/article/arca...
We link to GitHub because they have more infrastructure than we do for handling heavy read loads.
Generally speaking, we proxy requests and pass them through to the VCS after performing authentication and broad permission checks. Requests are rewritten slightly to remap user-facing display paths to actual paths on disk. Some additional features act through commit hooks.