Preview of Git Support in GForgeNEXT

Last week we rolled out a preview of Git support for GForgeNEXT and we are excited to share the first few working screenshots.  Before that, let’s run down the set of Git features supported in GForgeNext:

  • Access Git via HTTPS or SSH
  • Associate tickets to Git commits via commit messages.
  • Change the status of tickets via commit messages.
  • Web-based browsing of a Git repository.
  • Browse commits and view both in-line and side-by-side diffs.

Before we get to the screenshots of the Git related pages in GForgeNext, we invite you to participate in the GForgeNext Beta Program.  Finally, please read on if you are interested in additional Git related features on our development road map.

Git Information

Git_Info_-_GForge_AS_-_MyGForge

 Browsing Git

Git_Browse_-_GForge_AS_-_MyGForge

 Navigating Commits

Git_Commits_-_GForge_AS_-_MyGForge

View Diffs

Inline

Git_Diff__54bbbfb5f0d6cc66a446780285896cfb255428e3_-_MyGForge

Side-by-Side

Git_Diff__54bbbfb5f0d6cc66a446780285896cfb255428e3_-_MyGForge

If you like what you see above, check out these additional Git featured planned for GForgeNext:

  • Merge Requests – Request and perform peer code reviews right in GForge complete with annotations.
  • Better Diffs – Select two different commits and view the diff (inline and side-by-side).
  • Chat Integration – Chat will render Git commit hashes pasted into chat giving the user a summary of the commit (e.g. who, when, number of files, number of inserts/deletions) as well as allowing the user to click the commit hash to open up the Git diff viewer.

Again, if you would like to begin working with the features we already you can sign up for the GForgeNext Beta Program.

GForge v6.4.2 Released

Today we are happy to announce the release of GForge Advanced Server v6.4.2.  This is a primarily a bug fix release a few minor enhancements.

Download GForge Advanced Server v6.4.2 Now!

Notable Updates in GForge v6.4.2

  • Project Snapshots – We’ve a number of issues around project export and import.  If you need to move GForge projects between instances you’ll have to upgrade to 6.4.2.
  • LDAP/Active Directory – We now allow mixed mode authentication which allows users to login via LDAP/Active Directory or the database.  This is a great option for organizations that have internal users in LDAP and external stakeholders they want to give access to (via database accounts).  We have also provided a new script that will associate existing database accounts to their LDAP/Active Directory equivalents.
  • Syntax Highlighting – Web-based browsing of repositories now supports syntax highlighting.

The Gory Details

GForge v6.4.2 includes over 100 updates and few security updates so please be sure to checkout the Complete GForge v6.4.2 ChangeLog

Download GForge Advanced Server v6.4.2 Now!

HackISU: Ideas for Using the GForge API

Last week we announced that we’ll be sponsoring HackISU this weekend up in Ames.  This is a great opportunity for young developers and engineers to have fun and gain experience working with technology. For our part, we are awarding $3,000 to the team that makes the best use of the GForgeNext API which we also recently discussed. Ahead of this weekend’s event, we wanted to share a couple of ideas for teams looking to use our API.

Mobile is king these days and because we’ve been spending so much time working towards getting GForgeNext out of beta we haven’t had a chance to tackle anything related to mobile.  There’s a couple of fairly straightforward ideas in the space worth considering:

  1. A mobile application that works with GForgeNext tickets.
  2. A messaging application that brings the existing GForgeNext chat functionality to mobile device.

We should have prefaced that these are just two ideas and both are specific to mobile but you may be able to come up with your own ideas after you look at the GForgeNext API documentation.  Feel free to let your imagination roam.  So dive into these two ideas a bit more.

Working with Tickets

At the core of GForgeNext is the ability to work with tickets.  Tickets can represent just about anything but in IT they are used to manage a workload.  For example, we use GForgeNext internally as a place to plan which features and bug fixes will go into our releases and then to assign that work out.  Taking this a step further, GForgeNext also lets individuals manage their own todo list.  Basically as work (often across multiple projects) is assigned to someone, they can add that work to their own todo list in priority order.  Here are a few screenshots from GForgeNext showing the existing functionality:

Browsing tickets
Browsing tickets

 

Editing a ticket
Editing a ticket

 

Creating a ticket
Creating a ticket

 

 

 

 

 

 

 

 

 

Managing todo list
Managing todo list

 

So basically we are looking for similar functionality from a mobile application.  To help we think these features would be great:

  1. Authentication (logging into GForgeNext)
  2. Viewing your list of projects
  3. Switching between projects
  4. Viewing tickets for a specific project
  5. Adding a new ticket
  6. Updating an existing ticket
  7. Searching for a ticket (regardless of project) by ID.
  8. Logout

If that much can be accomplished then here are ideas for extra credit:

  1. View your todo list
  2. Edit your todo list (move in/out of list, change order tickets within queue)

Again, these are just features we came up with but we definitely encourage teams to consider other features they might find useful.

GForge Chat

Chat in GForgeNext is a critical feature because it allows project teams to collaborate on their work.  We are often asked the question, “Why would I want yet another messaging application cluttering up my workstation or mobile phone?”.  Indeed, there are a lot of ways to collaborate on projects like email, SMS, instant messenger, IRC.  However, the utility of GForge Chat is rooted in the fact is it completely integrated with your projects.  Before I get into those specifics here is the chat window in GForgeNext:

GForgeNext Embedded Chat
GForgeNext Embedded Chat

 

Standalone Chat
Standalone Chat

 

This shows how chat will work in GForgeNext.  The left shows that whenever you are viewing a page specific to a project you will see the embedded chat window.  Eventually you will be able to pop the chat panel out into its own window into something that looks like the image on the right (which is our standalone chat in our current product).

In GForgeNext, because every project gets its own chat room we can leverage features that won’t exist using other messaging applications.  For example as activity is happening on a project, it is streamed into the chat room (e.g. user joining chat, an updated ticket, a new wiki page being created).  Additionally when discussing tickets in chat you can create auto links to ticket by using #-notation (e.g. typing in #1234 into chat would be rendered in chat as a link to ticket #1234).

With that in mind, here are a few features we’d like to see in a messaging application:

  1. Authentication
  2. Viewing your list of chat rooms (projects)
  3. Switching between chat rooms
  4. View the messages in a chat room (including project activity)
  5. Viewing users in the chat room
  6. Submitting a new message
  7. Auto linking to tickets using #-notation
  8. Auto completing @-notation of users to mention them (see yellow messages in screenshots above)
  9. Logging out

That’s a pretty aggressive list of features but some extra credit ideas might be:

  1. Deleting one of your own messages
  2. Push notifications of messages you are @-mentioned in.
  3. Uploading an image

We know you aren’t new to messaging applications so, again, we really encourage you to only use the ideas above as a starting point and we definitely welcome other ideas you can come up with.

Heading into Friday

This is a lot to digest but we really do want teams that use our API to hit the ground running so please definitely read up on the API, feel free to register for a beta account by submitting your email on https://next.gforge.com and if you have any questions before this weekend’s HackISU event send an email to feedback@gforgegroup.com

GForge is Sponsoring HackISU 2016

hackisuWe are happy to announce we are sponsoring HackISU by offering over $3000 in prizes in several different categories.  Plus internships.  And swag.  HackISU is a Hackathon that will be held on the Iowa State University Campus on February 19-21.  This is a great opportunity for budding geeks to hack software, hardware and network.  As sponsors we are providing a couple of incentives for participants to learn, use and even hack GForgeNext.

Best GForge API Application – $2400 ($600 per team member)

Build something great using our API – like a mobile version of Team Chat, a Task/Queue manager, a Team Status Wall, or whatever else you come up with.

We’ll be around for nearly all of the HackISU event, ready to demo the API, answer questions and provide any other assistance that’s legal.  Check out the live API and docs right now at https://next.gforge.com/apidoc

GForgeNext Beta Users – $1200 ($100 per person, up to 3 teams)

Use GForgeNext to store your code, manage tasks, and stay connected using integrated project chat, for free.  We’ll pick up to three teams, and give everyone $100 each.

Even after HackISU is done, you can keep using GForgeNext.  We’ll keep it free for academic use, even after the full product goes live.

Instant Interviews for Paid Summer Intern Positions

Got a resume handy?  Bring a copy for us and we’ll do a quick interview on the spot.  Our summer interns get paid real-world money to build real-world software.  Interns turn into part-time and full-time GForge employees on a regular basis.

GForge-Branded Swag, of course

We’ve got t-shirts, stickers, all kinds of stuff.  Find a reason to talk to us, and we’ll give you something cool.

For more about the GForge Group: https://gforgegroup.com

Any questions prior to the HackISU weekend? feedback@gforgegroup.com

Announcing the First GForgeNext Beta

Today we are announcing the immediate availability the first GForgeNext beta. With GForgeNext we are taking what we have learned about project collaboration over 15 years and distilling it down to what you need right now.

Who is GForgeNext for?

This first beta is just that, a beta.  GForgeNext is a redesign of some of the key features we offer in GForge Advanced Server.  In other words, it is a minimum viable product (MVP) and it offers the following features:

  • The ability to create an unlimited number of private projects and quickly send project invitations to your team.
  • Git Support
  • A basic ticketing system that supports a kanban view and Git integration.  You can quickly attach screenshots and documents via drag-n-drop.
  • Team Chat which is integrated with Git and the Ticketing system.  Chat also support drag-n-drop of any file including rendering support for images and YouTube videos.
  • A REST-ful API
  • User’s can manage their own todo list across all their projects.
  • The ability to control who has access to various parts of your project.

We are offering GForgeNext absolutely free*, the only thing we require is that you give us feedback on a regular basis. To make the feedback loop easy we provide a feedback button on every page that allows you to report bugs and to share ideas and enhancements.

Ideal organizations will run projects with 5 or more team members and, while not required, we’d love to see some organizations in or around Iowa to open up the possibility of collecting onsite feedback.

Are you interested?  Please request access now.  Those users given access to this first beta will be able to invite other users to their projects.  All users participating in the beta, not just the leads, will be able to create their own projects.

Still not sure?  Further below we share some screenshots of an actual project using GForgeNext.  If you still have questions please send them to feedback@gforgegroup.com.

* We really do mean free.  The only caveat is we haven’t determined how long GForgeNext will be free but we do know it will be for at least two years and that customers that join us during this first beta will receive steep discounts whenever we do begin charging for access.

Who Shouldn’t use GForgeNext

GForgeNext’s current features are stable and can be used as-is with the expectation these features will always perform as expected.  In fact, we are using GForgeNext internally.  That said, there are some features we have planned that haven’t been implemented yet.  These features will be released throughout the coming year but if you require them immediately then you should not use GForgeNext:

  • Workflow support in the ticketing system.
  • Peer code reviews via Git
  • SVN support
  • A document management system
  • Team Chat in a separate window with support for multiple projects.
  • Custom roles and access control – GForgeNext currently offers the following pre-defined roles: Lead and Contributor but eventually you’ll be able to add new roles and customize their level of access.

For now, GForgeNext is only offered as an online service so customers who require the ability to run GForgeNext on their own, internal network will need to wait until later this year. Current customers using GForge Advanced Server will receive regular email updates on the progress of GForgeNext and we will share the date of the first stable release as it approaches along with guides for planning your upgrade.

GForgeNext Screenshots

Project Homepage

Project_Home_-_GForge_AS_-_GForge_Next_and_GForge_AS_by_GForge_Group___GForge_Discussions

Navigation via MegaMenu

Project_Home_-_GForge_AS_-_GForge_Next

Project Administration

Team_-_GForge_AS_-_GForge_Next

Browsing Tickets

GForge__6_4_2__Remaining__-_GForge_Next

Kanban View of Tickets

GForge__6_4_2__Remaining__-_GForge_Next

Editing a Ticket

__8999___Commit_M____-_GForge_AS_-_GForge_Next

Git Support

Git_SCM_-_GForge_AS_-_GForge_Next_and_GForge_AS_by_GForge_Group___GForge_Discussions

API Documentation

Entity__Trackeritem_-_GForge_API_and_GForge_AS_by_GForge_Group___GForge_Discussions

Git Workflow in GForge

While GForge has support for CVS and SVN, most of our customers have moved on to Git.  What gets buried in that integration is our customers have a choice on how to use Git and they can have GForge enforce some basic rules.  Today we are going to address implementing a common Git workflow in GForge.

For small projects with one or two developers you may not require workflow and in these instances you can happily clone, commit and push changes right to your master branch.  GForge has been engineered to accommodate even the smallest of projects so we support this model just fine.  Organizations with larger projects don’t want developers pushing code to their master branch because it typically represents the current, stable build.  Instead they opt for a review process of new code that is then systematically reviewed and tested before being pushed to master.  GForge’s Git integration supports this and to show how it works we’ll be using a real-world example.

Internally our work uses the same workflow for new development work and bug fixes:

  1. Task is created
  2. Task is prioritized and eventually assigned to a developer by a project lead.
  3. Developer does their work
  4. Developer requests a code review
  5. Code review is performed and, if successful, is published for testing
  6. QA confirms the code is working through a series of tests.

To support this, our tasks have the following workflow through statuses:

  1. Awaiting Assignment
  2. Accepted
  3. Ready for Merge (Code review)
  4. Fixed: Test for Release
  5. Fixed: Closed

The steps above represent the happy path for all tasks.  We have additional workflow rules to cover the not-so-happy path for things like failed code review or failed test results.  To make this work in Git we have the follow rules:

  1. Our master branch in Git is always our last stable release.  So while we are currently working on GForge v6.4.2 the master branch currently holds a snapshot of v6.4.1.
  2. We have an integration branch called gforge-next.  This holds all of the work that has gone through the above steps for v6.4.2
  3. Each task assigned out get it’s own work branch, i.e. #1234-bugfix-of-some-sort.  These work branches hold only the code required to satisfy the work described in a single, atomic, task.

So naturally there needs to be a way for a workbench to get into gforge-next and then eventually into our master branch.  To handle this our internal tracker has a custom field we’ve created called “work branch”.  When a developer starts work on a new task they will create a new work branch from gforge-next and give it a name i.e. #1234-bugfix-of-some-sort. When they commit their work to that work branch they will push it and then move task #1234 into “Needs Merge” status.  Another developer will checkout the work branch and perform the code review.  Assuming the code review is accepted, then the developer who did the code review will merge the work branch into gforge-next.  For all the other tasks in a given milestone this same process would happen.   Here’s a screenshot of a ticket awaiting a code review:

GForge_AS_by_GForge_Group___Projects___GForge_AS___Tracker___GForge___Edit_Tracker_Item

As that is happening we deploy the gforge-next branch to a server where we do our testing.  This means that as tasks hit the “Fixed: Text for Release” status, QA will grab the task and test the task works as expected.  Once the tests pass then the task is marked “Fixed: Closed”.

Finally as we close out a milestone, say completing v6.4.2, once all the tasks have been marked “Fixed: Closed” we will then prepare a new GForge release by merging gforge-next into master and then tagging that state of master with the version number being released.  Incidentally, once we have updated master we will then go in and remove all the work branches and then begin work on the next major milestone.

As you can see, we place no restrictions in how you use Git and you can implement any Git workflow you want.  If you have questions regarding this feel free to post a comment below or customers can send questions to support@gforge.com.

Getting Out of Your Way

When I talk to customers about GForge, I often describe it in terms of parenting.  For product managers, their products are their children and good parents see all the untapped potential alongside any rough edges.  Like parents, product managers often spend a disproportionate amount of time playing up their products strengths while downplaying those rough spots.

GForge and nearly every product in our space shares a common flaw: we get in the way too much.  Product managers fantasize about how much customers use their products and, while understandable, sometimes the measure of a great product or feature is how much it gets out of our way. Let’s explore this concept with a concrete example.

As we’ve been redesigning GForge, everything related to the customer experience is on the table.  Over the past few weeks we’ve been finishing up how leads, PMs and individuals manage their work.  For most organizations this means multiple projects with competing priorities fighting for engineering time.  This process usually goes through a review by leads or PMs resulting in work being dished out to team members who then have to figure out how to factor those competing project priorities to build their work queue.  Worst yet, this process often happens multiple times each week with the team members organizing their queue on a daily basis.  Compounding things, each organization has a toolset that is meant to facilitate some or all of this process and here-in lies the problem.  While the tools often facilitate organizational process, they are often clunky and impose team members to do interact with the tool more than needed.  This is the exact sort of problem GForgeNEXT is trying to fix.

So what are our goals in the specific case?

  1. It has to be easy for leads and PMs to prioritizing work ahead of assigning tasks to team members.
  2. Leads and PMs want to quickly prioritize team members tasks, many of which, reach across milestones or other projects.  To be clear, we are talking about prioritizing work across projects and milestones where tasks, in many cases, have been given the same priority.
  3. As an alternative to #2, above, some organizations prefer to give team members the flexibility of prioritizing their assigned work across projects and milestones.
  4. Leads and PMs want to monitor an individual’s contributions and tasks (again, across projects and milestones).
  5. Team members want to work through their queue without having to constantly refer to to their list.

To drive home the need of tools needing to get out of the way of teams let’s show how GForgeNEXT addresses this.

Prioritizing and Assigning Project Tasks

Admittedly, GForgeNEXT isn’t doing anything truly revolutionary in this area.  The fact is to prioritize and assign work on a project, you simply can’t get around building a list and then setting the priority.  In fact, you’ve always been able to do this quite well in GForge but we did add a few wrinkles to make this easier.  First, when building your list, we’ve made it easy to quickly add a tasks:

New_Item_in_GForge_-_GForge_AS_-_GForge_Next

As you see, you can now save and quickly navigate to add additional tasks eliminating the step of going back to any list. Once you’ve built your list you can further refine the priority and assignment of tasks:

GForge__First_Dozen__Remaining__-_GForge_Next

One minor feature we added is the ability for team members quickly add a task to their own queue.  While browsing tasks they can click on the star icon which will a) assign the task to the team member and b) add it to the end of their current queue:

GForge__First_Dozen__Remaining__-_GForge_Next

Probably the biggest enhancement to the task list is that they are all part of a polling loop to reflect external changes. That means if you are working through prioritizing project work in a phone call or meeting one person can change the priority (or status, assignee, etc) and anybody else viewing the same page will see the changes.

Prioritizing Work Across Projects and Milestones

To this point we’ve shown how to manage tasks within a project, however, if you are in an organization with multiple team members working in a growing project portfolio you need to have a handle on how that work is prioritized work across projects with competing priorities and deadlines.  This is equally true for team members who may have the flexibility to make their own decisions on how to prioritize their tasks across projects.

In GForge you could already view your assigned work and even manage that work within your own queue.  While the feature is there and it works GForgeNEXT simplifies all this:

hectorpizarro___my_-_GForge_Next

What you see above really addresses three basic questions for any given person:

  1. What has this person been assigned?
  2. What are they currently working on?
  3. What have they completed?

If this sounds familiar, that’s because this is what nearly every “status meeting” in nearly every organization has covered for decades.  “Status Meeting”, “Stand-up Meeting”, call it what you want, those are the three basic nuggets of information they are all after and they account for significant productivity waste.

When viewing an individual’s queue, GForgeNEXT gives you the answer to those three questions.  See, access to an individual’s queue is based on the relationship of the viewer, specifically, leads and PMs can now monitor and optionally manage their team member’s queues.  Obviously this also implies users can manage their own queues and all of this is done by dragging cards between the Assigned and Queue columns or moving cards within the Queue column to set the order.

Finally, just as when browsing tasks, when you are viewing an individual’s queue, any external changes made either by the individual or a lead/PM will be automatically reflected .

Working Through Your Queue

Once the lead, PM and the individual have setup their respective queues team members can begin work.  What’s important here as while the queue exists we have tried our hardest to make complete taskseffortless. For example, you can quickly view your queue fight from the menu in GForgeNEXT:

GForge__First_Dozen__Remaining__-_GForge_Next

From there, as you complete work in your queue you can simply access the next item using the What’s Next button which will save your work and take you to the next task in your queue:

__10620___Update_____-_GForge_MVC_Library_-_GForge_Next

Again, Let’s Get Out of Your Way

As I’ve said before, we don’t pretend any of this is truly revolutionary but as we continue product development on GForgeNext we continue to not only listen to our customers but figure out how we can reduce friction so your teams can focus on getting work done.  Regardless of whether you use GForge or not, let us know how your organization manages work and if what we outlined would fit your organization.  Finally, If you’d like to take a closer look at GForgeNEXT we invite you sign-up for our beta program which will be launching soon.