Archive for the ‘FogBugz’ Category

Sign Up For the FogBugz Beta (Closed)!

March 26th, 2013 by Aaron Maenpaa

Update: The beta is now closed. A big “Thank You!” to everyone who signed up.

 

Want to see what’s coming in the next version of FogBugz? Now you can! The FogBugz team has been hard at work on a project we’ve code-named ”Ocelot” for the past several months. We’ve rebuilt the core pages of FogBugz to use a completely new architecture that’s significantly faster. Like, seriously fast. And now we’re ready to start sharing it with you!

 

What’s shiny and new?

The new version of FogBugz is a single page app when it comes to the list page and the case page. What’s that mean exactly?

  • a super fast list page for listing and filtering your cases
  • a wicked fast case page for viewing and editing individual cases
  • blazing fast search for finding the cases you’re interested in
  • and blink-of-an-eye fast transitions between these pages

We’ve been dogfooding the new UI internally for a couple of months now and it has really improved our own experience of using FogBugz. We hope you’ll like it!

Riding the Ocelot

 

A Word of Caution

This is a beta, so there will be bugs. If you find one, please contact our customer service team and let them know. Furthermore, since we’re trying to get this into your hands as soon as is humanly possible, there are some caveats to the beta:

  • The beta is for FogBugz On Demand accounts only.
  • The beta UI has only been tested in Firefox and Chrome. Support for IE10 and Safari are on our TODO list and they should mostly work, but they might not and you will probably run into cosmetic issues.
  • Customizations from the BugMonkey Plugin will not apply to the beta UI.
  • With a few exceptions, existing plugins will not interact with the beta UI.
  • A number of features have not yet been implemented including:
    • Custom fields
    • Quick case add on the list page
    • Graceful handling of concurrent case editing
    • Similar speed improvements and single-page-appification to Wikis, Discussion Groups, Reporting, Admin pages, etc.
    • The Working On menu
    • Searching Wiki Pages and Discussion Groups from the main search box
  • With the exception of some specific text used in outgoing emails, the beta UI is not localized

 

Share your Feedback

We’re looking for feedback on: How the application feels, your general impressions, any missing features that impact your day-to-day workflow, and of course any bugs you find. Once you’ve started using the beta, please contact our customer service team and let them know what you think!

Once your account is enabled for the FogBugz Beta, you can enable and disable the beta UI on a per user basis from a link in the top right corner. If you later decide that you’d like your entire account taken off of the Beta, just let us know and we’ll be happy to take care of that for you.

Sign Up!








Dogfooding Until It Hurts

February 26th, 2013 by Rich Armstrong

Dogfooding. Also called “eating your own dog food.” It’s pretty simple, right? If you work at Uber, maybe take an Uber car ride from time to time. If you work at Khan Academy, you’re probably pretty good at math by now.

In this video from 2009, Joel talks about dogfooding as being more than just using your own product. It’s about using your own product for everything you can imagine, even if that usage is a little uncomfortable.

We dogfood Trello, FogBugz, and Kiln in a ton of different ways.

We’re a software company, so we generate a lot of code. Kiln helps with that. But we even use it to hold things that aren’t “code” per se, such as backups of non-sensitive databases. We don’t have any real crazy use cases, like using code reviews to plan parties or the electric DAG to create subway maps, but that’s just because Kiln has only been around a few years.

FogBugz, on the other hand, we use for tons of off-label stuff. We use FogBugz’s crash reporting ability to read RSS and Twitter feeds and create cases when new items appear. We use its customer email capabilities to receive faxes. And we have a panoply of API scripts automating a bunch of different business processes.

Trello is a natural for dogfooding, of course, because it’s so flexible. We keep kitchen snack requests and lunch menus on boards. We keep track of who’s going to what conferences, and use it to plan their travel. Trello really shines in setting the agenda for and running our bi-weekly company all-hands meeting. Because Trello is so flexible, it invites a lot of different use cases. We’re still figuring out which ones really work, and it’s great to see a fast-growing user base figuring that out alongside us.

So, that’s all well and good, but if you really want to see “dogfooding until it hurts” in action, check out Beeminder, a tool for setting “goals with a sting.” You set up your goals, and if you stray from them, the service fines you an escalating amount of real money until you’re back on track. Beeminder is dogfooding heavily and publicly to keep their development goals on track. These folks are  literally giving away cold hard cash to users as a pre-commitment to do things like delivering user-visible enhancements or blog posts on a regular basis. Amazing. Even better, they have a Trello integration that’ll keep you moving those cards to the Done column regularly (or else).

 

BugzScout: Simple Free Crash Reporting

February 11th, 2013 by Rich Armstrong

BugzScout helps you improve software quality by aggregating stack traces under the version, file and line they occurred on.  Here’s Joel and Tyler explaining it a few years back.

 

 

BugzScout certainly isn’t the only crash reporting solution out there. It’s not even the most full-featured (and, shhhh, that’s often why we like it). Crashlytics is a good one. Airbrake has traction in the Rails community. For mobile app development, we’ve found Crittercism invaluable. But BugzScout is simple and flexible, comes free with FogBugz and Kiln, and actually has many uses beyond crash reporting. (We use it as an RSS feed reader! Ping us to learn how.) No matter how many times the crash occurs, only a single case is created. It’s much more civilized than, say, flooding your inbox with a zillion dupe crash reports.

Have FogBugz and want help implementing BugzScout for your project? There’s a BugzScout section in our online webinar. Or, if you need personalized help, let us know!

Interested in making your software better through crash reporting, but don’t have FogBugz? Start a trial and get in touch!

IFTTT Notifications in FogBugz Cases

January 17th, 2013 by Max Kramer

With Ben M firing off useful, pithy blog posts faster than Rick Moranis traveling in space, there sure is a lot to keep track of on the Fog Creek blog these days. To make sure our Sales team stays abreast of new posts, I threw together a simple IFTTT mashup that activates reminder cases within their normal FogBugz workflow any time a new post comes out.

While IFTTT doesn’t currently have a FogBugz channel, it was easy to set up a recipe that monitors our blog’s RSS feed and emails a FogBugz mailbox after any feed activity. Here’s the cool part: when sending an email into FogBugz, you can seamlessly route it to a specific case by including the case number in the email’s subject line. So, all I had to do was create an IFTTT recipe and corresponding FogBugz case for each team member, include the respective case number in the IFTTT action’s subject line, and voilà! Now each Sales member is notified within FogBugz any time a new blog post comes out, and they’re free to close the case, set a Do Later task, forward it to their weird uncle, or do anything else they see fit.

Linear Workflow in FogBugz

September 21st, 2012 by Ben McCormack

The default workflow in FogBugz is pretty simple:

  1. Assign a case to someone.
  2. When they resolve the case, it gets assigned back to you.
  3. Verify & Close the case or Reactivate it.
  4. Rinse and repeat.

You can customize the default workflow using the Workflow Plugin, which will let you change the person who gets assigned a case for a particular status. However, sometimes you want to be able to move a case between various steps, e.g.

Dev  →  QA  →  Production

We wanted to make it easier for FogBugz users to visualize this kind of linear workflow, so we wrote a simple BugMonkey script that shows you the workflow at the top of the case and gives you a button to click to go directly to the next step. Here’s a quick video walkthrough:

This is a really simple way to add workflow to your cases and shows how powerful BugMonkey can be to customize FogBugz. Get the script and add it to FogBugz via My Settings > Customizations.

FogBugz and Trello Homebrew

September 6th, 2012 by Ben McCormack

When we launched Trello last year, we immediately heard from customers that they wanted Trello integration with FogBugz. It’s a reasonable request:

Fog Creek made FogBugz.

Fog Creek made Trello.

Fog Creek should make them play nicely together.

So over lunch, I asked one of the FogBugz developers, Why haven’t you made a Trello Plugin yet?” And he responded, “We would love to make a FogBugz plugin that integrates with Trello! What do you want to see?”

I drew a blank.

The solution wasn’t immediately obvious to me and I couldn’t think of a good design off the top of my head—certainly there is a good solution; it just wasn’t obvious to me what it should be. There are a billion different ways you might present FogBugz data in Trello. Plus, Trello is still maturing and (currently) lacks web hooks. Both of these things make integration with FogBugz a bit challenging at the moment.

There’s not a FogBugz-Trello integration plugin yet, but several customers expressed an interest, and I was sure I could help them out. We recently talked to a FogBugz customer who uses multiple Active statuses in their workflow and uses Milestones to break up sprints. Something like this:

FogBugz: All Cases in Sample Project Broken Down by Milestone

Given their workflow, their request seemed pretty reasonable. For a given project:

  • FogBugz Milestones as Trello Boards
  • FogBugz Active Statuses as Trello Lists
  • FogBugz Cases as Trello Cards, with a link back to the original case.

I decided to use the FogBugz XML API and the Trello API to see if we could make that view possible. Turns out it’s not that hard and this is what you get as a result:

Trello view of FogBugz Cases

Each card even has a little Kiwi icon that you can click to go right to the case in FogBugz (On Demand only). The script only updates one way (FogBugz => Trello), but I think it’s a nice visualization for this particular workflow. You can get the script here: Milestones to Trello.

Of course, you should modify the script to fit your needs. Would you prefer to see Projects as Boards with Milestones as Lists? Areas as Lists? Edit the script any way you like, and if you come up with something you want to share, send us an email and we’ll add it to our FogBugz recipes.

Do you have an idea for how FogBugz and Trello should play together? Let us know what’d you like to see by leaving an answer on our Trello Integration post.

At Long Last: The Case Merge Plugin!

August 30th, 2012 by Quentin Schroeder

We have a variety of methods for tracking what features our users are looking for, and by every measurement available, the ability to Merge Cases was at the top of the list! In fact, this has been a top feature request for quite some time.

We’ve had our eyes on this feature for a while now and even drafted a feature specification for it, but while we were drafting ideas, a user from the FogBugz Developer Community contacted us with a fully functional plugin that solved the problem! So, without further ado, may I present the Case Event Merge Plugin, written and generously shared by the developers at Quarantainenet:

“The FogBugz Case Event Merge plugin adds the functionality to display the case events of a duplicate case in the original case…. We have tried to overcome the design problem of merging by not merging at all: we just display the events of one case in the history of the other, keeping the workflow of cases intact.”

Here’s a quick video that goes over how it works:

The Case Event Merge Plugin is available for both FogBugz On Demand and customers running FogBugz on their own server. Follow the installation instructions to get started, and check out the full documentation to see what the authors have to say about it. Read on for a bit of history on the development of this plugin.

 

Why was this feature so hard to add?

After Quarantainenet knocked the ball out of the park with this plugin, it is easy to look at it and wonder why Fog Creek didn’t deliver it earlier. The answer lies in the details, or to be more accurate, the lack of details.

The solution that Quarantainenet devised is simple because it does not manipulate the existing rows in the database. In the feature specification draft that we were working on at FogCreek for merging cases, we were looking at it from the opposite perspective and dealing with the repercussions of trying to move the bug events from one case to the other within the database. In this scenario we had a lot of corner cases and questions that weren’t trivial to deal with.

For example:

  • Once a case is merged to another, does the system delete it?
  • What happens with new incoming emails that have the case number for the now-closed duplicate case?
  • Do we try to merge the attributes of the two cases together?
  • How do you seamlessly transition the conversation to the new case and discourage updates to the old one?

Each of these questions has valid possible solutions that we considered, but would lock the users into a specific workflow, which was something we were trying to avoid. The ability to merge cases had to make life easier for users who kept getting emails with the Case keyword stripped from it, or those infamous CC chains that seem to spawn an endless number of new cases. The solutions we were batting around made life easier in about eight out of ten scenarios, but made life a lot more confusing in those last two cases. The net gain was teetering on the edge of positive, which meant producing it just wasn’t worthwhile.

 

A Fresh Approach

The genius of the Case Event Merge Plugin is that the only data it requires is a marker for the duplicate cases whose events we want to display in the other case. The real work comes when FogBugz goes to render a case view page; the plugin interacts with the rendering process and creates a bunch of “pseudo bug events” from the duplicate cases. (The Kiln plugin uses the same pseudo bug event mechanism to show changesets inline with the rest of the case). These events are read from the database just as they would be if the user went to view the closed duplicate case. What this means is that the Plugin can crash, fail, be deleted, mucked with and otherwise abused and your original data is left completely intact.

Because Quarantainenet was never thinking about manipulating the existing Bug and BugEvent tables, their solution exclusively utilizes the rendering of the case view. This means that all of the core FogBugz code gets to keep chugging happily along, completely oblivious to the fact that these two cases are anything but “Resolved as Duplicates”! It’s simple, elegant, and it just works.

This plugin is already being used heavily at Fog Creek and we know many of our customers are excited about its release as well. Several years after the feature request first appeared, we’re glad that we can finally mark it as Resolved (Implemented).

How to Make a Local Copy of Your FogBugz Data

August 27th, 2012 by Ben McCormack

If you’re using FogBugz On Demand, we’re already regularly backing up your database. However, we do occasionally bring the system down for periodic maintenance, and one of our customers wanted to know how they could maintain a local copy of their important FogBugz data just in case our services were unavailable. They didn’t necessarily want the database itself, but just a way to look at case data in a pinch.

While we never plan downtime during your productive work hours, we can empathize with always wanting a local copy—just in case—in order to stay productive (for your source code, we of course offer a distributed version control solution, which promises exactly that).

To solve this problem, we added a simple script called ‘Backup FogBugz’ to the recipes section of the FogBugz XML API Development wiki. It checks FogBugz for unread cases, then saves the updated case info to a local HTML file. It doesn’t save everything—you wouldn’t be able to e.g. restore FogBugz with this data—but it does give you a relatively fresh copy of the data on your local machine.

Here’s a quick video overview of how it works:

Take Control of FogBugz

August 15th, 2012 by Ben McCormack

If you’ve been using FogBugz for a while, you’ve probably mastered filtering and searching, you resolve your cases like a boss, and you even have time left at the end of the day to make a nice outline of work for an upcoming feature.

So, how can you take your use of FogBugz to the next level? Customize it!

We built FogBugz for developers, so we weren’t shy about adding multiple ways to customize FogBugz. Let’s put on our Mr. Rodgers sneakers and comfy cardigan, and take a little look.

XML API

The FogBugz XML API provides a way for external services to interact with FogBugz. For example, you might write a script that randomly assigns “Up for Grabs” cases to different members of your support team. For even more power, you could combine your use of the XML API with the URLTrigger plugin, which will fire a web hook to your service and allow you to respond to events in FogBugz in near real-time. Want to receive a text message when a priority 1 case is created? Use the URLTrigger plugin to be notified of the event, then use the XML API to note in the case that a text message was sent.

Ideal for: Quick & malleable FogBugz hacks; scripts.

Additional Resources:

FogBugz Plugin API

If you want your customization to live inside FogBugz, consider writing a plugin. There are already quite a few publicly-available plugins in the plugin gallery, but you can also write your own using any .NET language. A common use case for writing a plugin is when you want to integrate with an existing customer database, perhaps a CRM system.

Ideal for: Tightly-integrated solutions that justify increased upfront development time.

Additional Resources:

BugMonkey Customization

Ever heard of Greasemonkey? BugMonkey is the same thing, allowing you to add custom JavaScript and CSS to FogBugz, except that your customizations live inside FogBugz. Have you ever tried embedding a Google Calendar or Google Doc in a FogBugz Wiki? FogBugz won’t let you. However, you can get around that with a simple BugMonkey customization for either Google Calendar or Google Docs.

Ideal for: Visual customizations, user interface tweaks

Additional Resources:

Source Code Modification

Woah! Yes, it’s true that if you run FogBugz on your own servers, you have access to the source code. However, if you modify the FogBugz source code, your installation may be in a position where we can no longer support it.

Now that we’ve gotten that out of the way, why would want to modify the source code? Most likely, you wouldn’t. Between the XML API, FogBugz Plugin API, and BugMonkey customizations, you should have more than enough at your disposal to mold FogBugz to your heart’s content. That being said, there are times when FogBugz doesn’t quite work the way you want, and modifying the source code is the only option, like if FogBugz’s LDAP code doesn’t work with your LDAP configuration, you might tweak the source code to get it to function correctly.

If you do decide to modify the source code, please contact us first to make sure that your installation can continue to be supported.

Ideal for: Necessary changes that can’t be fixed by other methods

Additional Resources:

Now that you see your various options to change and customize FogBugz, you can put together a custom solution that will benefit your team. Even at Fog Creek, where we have full access to the source code, unless it’s something that needs to ship we build  little tools to do the job. We’ve made several plugins, multiple scripts against the XML API, and tons of BugMonkey customizations to tweak FogBugz to our liking. We encourage you to do the same, and if you have any questions, feel free to contact us for help.

Source-Control-Like Comments for Timesheet Intervals in FogBugz

April 18th, 2012 by Adam Wishneusky

As a support engineer here at Fog Creek, I get to play around pretending to be a programmer sometimes, mostly to help customers with Plugin and XML API codez. I recently collaborated with an intrepid FogBugz user to create this plugin which allows you to put a comment on each time interval. It adds a [comment] link in the timesheet editor:

timesheet editor

When you click it, you can enter a comment in a new dialog:

comment dialog

which then shows up in in the editor:

timesheet editor with new comment

The plugin uses some javascript hackery to modify the timesheet editor since there is no plugin interface to implement to change its functionality. As such, it works with FogBugz 8.7 and is not tested and approved for FogBugz On Demand. You can download the plugin to run on your own local FogBugz server, and get the source code from our public Developers repository on Kiln.