Spring into Axosoft v19.0! Our team has been hatching up some bright new features and blooming bug fixes to enhance your Axosoft experience.

More Organizing Options with Sections

Sections have sprung! You may now organize your fields into groups called sections. To access this feature, navigate to Tools > Fields > Field Templates, and then edit any field template to build out a section.

You can see these sections appear when in View or Edit mode with any items that use the field template in question.

Editing Field Values from List View

Users may now right-click to edit fields from the List View by using the context menu to make a different selection. No more hopping back and forth between screens.

Editing Checklist Fields

Users can now edit existing text in custom checklist fields, making it much easier to correct typos and update tasks. Chick ching!

My Item History Tab

When you go to add a new tab, you will now see an option under Publicly Saved Tabs for a new tab called “My Item History.”

Click My Item History to add the tab, allowing you to review the most recent items you’ve  made changes to. This should come in handy for tracking down items you just closed or modified.

If you don’t have the History tab enabled, have your administrator turn it on from Tools > System Settings > General > Main Tab Visibility > Miscellaneous.

Toggle Details Pane

You may now use the keyboard shortcut Shift + d to toggle the Details Pane open and closed.

Help Desk Arrow Navigation

It’s a sunny day for you Help Desk power users!  You may now use Next and Previous arrows within an email to browse through that email’s thread.

That about covers what’s new in Axosoft v19! To see a complete list of improvements and bug fixes, checkout the current release notes.

We recently announced the introduction of public APIs for GitKraken Glo Boards; to help us celebrate, we invited our community of incredibly talented and creative software engineers to develop app integrations as part of our Glo API contest.

Hopeful API developers submitted their integrations for the chance to claim up to $10,000 in cash prizes! Contest categories included: Import/Export/Sync Tools, Slack Integrations, Chrome Extensions, Screenshot Tools, Time Tracking, Voice Assistant Integrations, IoT Integrations, CI/CD Integrations, IDE Integrations, and Freestyle. We are extremely thrilled to announce the winners and share details about their digital creations.

Glo Marketplace Launches

The new Glo Marketplace features the free apps listed below, and it’s constantly growing as developers submit Glo API apps. So keep checking back to find apps that further enhance your productivity using the Glo issue tracker in combination with other apps.

Glo Web Clipper

Chrome Extension, Screenshot Tool

Thanks to the Glo Web Clipper, users can now avoid the three-step process of creating a screenshot, saving it to their computer, and uploading it separately to Glo. That’s right! You can now immediately add a screenshot to an existing card while in Glo.

You can create and share the following web snippets through this application:

• Visible Page: a screenshot of everything that is currently visible on your screen.
• Full Page: a screenshot of the full page, including everything that is not visible.
• Selection: allows you to freely select a rectangle to clip on the currently visible page.

After creating your web snippet, you can either create a new Glo card and attach the file to that card as a comment, or you can add the file to an existing card as a comment.

Glomium

Chrome Extension, Time Tracking, Screenshot Tool

The Glomium application is a multi-faceted tool that allows a variety of features for communicating between Glo and other web pages. You can create cards, attach files, make comments, and track your time directly through the Glomium Chrome extension.

The Chrome extension provides a simple drop-down menu giving users the option to:

• Create cards using the + icon. You can select the board where the card should be posted, add a name and description, attach files, and use Glomium’s one-click tool for adding the webpage’s URL.
• Post comments to existing cards using the extension’s drop-down menu.
• Track time spent on specific projects using the built-in time tracker functionality. You can use the time tracker while working on projects inside or outside of your browser. Then post your recording time as comments to any cards in Glo!

Kraggl

Time Tracking

Glo users can now use Toggl from inside Glo Boards to track time spent working. Not only does Kraggl allow users to track time using the start and stop timers, it also offers reporting capabilities to evaluate time spent on specific issues or workflow steps.

After installing the application and providing access to your GitKraken account, you will be able to specify columns that you want to track time spent on. Users can easily start timers for specific projects or tasks by moving existing Glo cards to columns designated for tracking. Similarly, stop the timer by moving a Glo card from a tracked column into a column not marked for time tracking.

Another super cool feature of this application is the integrated time summary, which allows you to quickly see how much time has been spent on each card. Similarly, column time summaries will show you the total time spent on the project by adding up the time spent on each card listed in the column.

Glowify

Freestyle – Gamification

This application allows users to gamify their Glo Boards. Users can publish new boards in Glo directly from Glowify, which will populate in the Board Panel and continuously update with earned points and achievements.

Glo users will start receiving points as they engage with their Glo Boards by adding cards, completing tasks, and performing other actions (listed in Glowify as Events).

As users continue to earn points, they will move up the ranks—seen by having their card moved to the next column to the right—and receive labels for special achievements. The rank titles and associated point requirements can be managed from within the Glowify application.

JGlo

IDE Integration

This application allows users to complete all basic Glo Board actions directly from any JetBrains IDE product, preventing context switching and productivity loss! To make things even more convenient, this application can share your access token across different IDEs, saving you from having to authenticate multiple times.

Compatible JetBrains products include:

• IntelliJ IDEA
• PyCharm
• WebStorm
• PhpStorm
• Rider
• CLion
• RubyMine
• AppCode
• GoLand
• DataGrip

JGlo also integrates with the IDE Android Studio.

After setting up your integration and authenticating the JGlo app, you can start adding boards, columns, and cards without leaving your JetBrains IDE tool. Users can also move and edit boards, columns, and cards with JGlo.

Flo

Slack Integration

Never miss any action in Glo! Use Flo to receive real-time notifications in Slack about activity happening in Glo Boards—whether you’re assigned a task, a progress change has been made on a project you’re working on, or a team member has left you a comment.

Mini Glo

Voice Assistant Integration

Hand fatigue? Mini Glo is the app for you! It’s an Alexa Skill that allows you to use your Amazon smart home devices to talk with Glo Boards. So you can use speech commands to perform tasks within Glo. Say whatttt??!!

Users can start by saying, “Alexa, open Mini Glo.” Then can ask Alexa at any time how to perform specific tasks (like create a column) by saying, “Alexa, ask Mini Glo how to do (insert task).”

As seen in the video, Mini Glo can add columns, create cards and add them to columns, delete boards, and more.

GitTrackin

GitLab Integration, Chrome Extension, Time Tracking

A Chrome extension, GitTrackin helps sync and track time across Glo and GitLab boards.

Though webhooks, GitTrackin syncs data from Glo to a user’s GitLab issue board. Users can create/edit columns, cards, and labels in Glo, and see those changes reflected in your GitLab issues.

The GitTrackin Chrome extension is complete with a built-in stopwatch, allowing you to start, pause, and stop time spent on specific tasks. Courtesy of the webhook, the time tracking feature is displayed in both Glo and GitLab, providing better visibility when working with both tools.

Glo CI

GitLab Integration, CI/CD

Cheers to DevOps!! Glo CI integrates Glo with GitLab CI and Travis CI so you can trigger your continuous integration (CI) and continuous delivery (CD) builds by moving cards into specific columns.

Creating a card from within Glo will immediately trigger a new CI/CD build in your CI provider. After the build succeeds or fails in your CI provider, the card is automatically moved into another column that describes its new status. The card will now include a comment describing the status.

Glo IoT Stopwatch

IoT Integration, Time Tracking, DIY Hardware Project

Unlike any of our other submissions, this application comes with a build-it-yourself stopwatch for time tracking! How fun is that!? Who doesn’t want to smash buttons while they’re working?

Use one button to start and pause the time, and the other to indicate the task has been completed. After hitting the button to complete the task, your Glo Board will automatically update with a comment, noting the task is complete AND the amount of time spent.

This application comes with a DIY 5-10 minute tutorial to build the tool yourself using an ESP-8266, buttons, wires, Nokia 5110, a power bank, and a box.

Submit an App to Glo Marketplace

Do you have a great idea for an API integration for Glo Boards? Tons of users are looking for productivity apps to extend the functionality of Glo Boards, and by having your app featured in the Glo Marketplace, you will get the greatest amount of exposure.  Submit your Glo App anytime, and we will review it for placement in the Glo Marketplace. Continue to check the Glo Marketplace for new apps that will enhance your Glo Boards experience.

Syncfusion prefers a Git workflow for managing all our complex products across a variety of platforms. Our day-to-day work has been simplified since adopting the Gitflow model in our development phases.

As developers, our responsibility is not only to fix issues or implement new features, but to clearly communicate the development work to reviewers. A developer can convey proposed code changes and their purposes either through detailed documentation or other means of communication.

Here’s where the inevitable descriptions of pull or merge requests come into play, where the code contributors share detailed comments on their code.

The GitKraken team thoughtfully considers team collaboration when developing its tools: the GitKraken Git client and Glo Boards. There are numerous opportunities to add significant context to your file changes and pull requests from within GitKraken, which supports pull request templates committed to remote repos on GitHub, GitLab, or VSTS (including Azure DevOps with legacy VSTS URLs). More on that later…

What Role Does a Description Play in a Pull Request?

Providing descriptions for pull requests is highly recommended for a better code review process. Descriptions clearly answer:

• What can reviewers expect while reviewing the submitted code?
• What standards has the developer considered before submitting their code for review?

Later, the reviewers can initiate an open discussion between themselves and the developers to track every code change before those changes are pushed into repositories.

Description Checklist

To make a pull request as clear as possible, it should include an appropriate checklist of relevant information about the proposed code changes (instead of a single line summary), such as:

• How a bug was fixed and a description for the  solution.
• A description or summary of a new feature.
• The unit test cases covered.
• Whether this code breaks existing functionalities.
• Any testing details.
• Whether it was tested in all devices and browsers.

Wouldn’t it be nice if these checklists showed up automatically in the description field every time you made a new pull request? Good news! The Gitflow model offers this ability through the template option.

And better yet, GitKraken makes it painlessly easy to access your templates throughout your workflow. We will review exactly how to utilize pull request templates in GitKraken later in the article.

You can see an example of how these descriptions are viewed in a pull request in the following image.

What is a Pull Request Template?

When you initiate a new pull request for an implemented feature or a bug fix in your project repository, you can allow the description field to pre-populate with  a checklist of items relevant to your team, like the checklist provided in the previous section. This process of exhibiting the pre-filled description field in pull request form is often referred to as a Pull Request or Merge Request Template.

For an automatic pre-population of details in the description field, you must first define your own set of templates and then add them to the project’s root directory. You can also create multiple templates separately for bugs, features, documentation, etc..

The description templates are usually drafted as Markdown files and should be added to the appropriate directory of your project repository. The naming of a directory, as well as the handling of single and multiple templates in your project repositories, differs based on what service you prefer to use: GitHub or GitLab. For the purposes of this article, we are going to focus on GitHub.

As an example, you can reference the checklist defined in a Markdown file, making use of the task list syntax shown in the following screenshot.

The same task list will be displayed in the submitted merge request page as follows.

How to Create a Single Pull Request Template in GitHub

If your project repository is on GitHub, the name of the template and where it’s located in your repository matters a lot. The template created as a Markdown file should be named PULL_REQUEST_TEMPLATE.md by default and placed in either the project’s root folder or .github directory.

Create a Markdown file, name it PULL_REQUEST_TEMPLATE.md, and place it in the project’s root folder.

Or, create a directory, name it .github, and place the Markdown file in this folder.

Now, when you create a new pull request, you will see the template content automatically loaded into the description field as shown in the following image.

Utilizing Pull Request Templates in GitKraken

As we briefly mentioned earlier, GitKraken supports pull request templates committed to remote repos on GitHub, GitLab, or VSTS (including Azure DevOps with legacy VSTS URLs).

When you create a new pull request in GitKraken, the Pull Request Template drop-down menu will appear, allowing you to select a pull request you have created in one of your repositories. This allows you to easily and quickly fill in your pull request using all the information designated on your pre-drafted template.  

How to Create Multiple Pull Request Templates in GitHub

It wouldn’t be sensible to use the same description template for different categories of pull requests. For example, you may need to initiate a pull request for submitting the code changes of a newly implemented feature, a simple bug fix, documentation, or any kind of configuration work. It would be best for each of these pull request links to load and pre-populate different template contents in the description fields based on the submitted pull request category.

To make use of different templates, you must first create multiple template files and save them as separate Markdown files in your repository, as explained in the following steps:

1. Create a folder named PULL_REQUEST_TEMPLATE and place it within either the root directory or the directory named .github.
2. Create multiple template Markdown files and place them all in the folder PULL_REQUEST_TEMPLATE.

If you do have multiple template files in GitHub, you will always need to manually navigate to the URL of the specific Markdown file you want to pre-populate in the pull request form.

For example, I’m creating a Markdown file and naming it bug-template.md. I place it in the PULL_REQUEST_TEMPLATE folder of my main repository. When I want to push some changes into this main repository, I will initiate a new pull request. To pre-populate my pull request form with the content of the bug-template.md file, I need to navigate to the URL by passing an additional template parameter:

https://github.com/Scheduler_Project/compare/master…Test_branch?expand=1&template=bug-template.md

Here, Scheduler-Project refers to the name of my main repository and I’m trying to merge the code changes from the Test_branch into my master branch. At the end of the URL, there’s template=bug-template.md to pre-populate the content of the bug-template.md file into my pull request form.

Now, after making these URL changes, you can see the description content being loaded in the pull request form as follows.

You can edit the previous description with relevant details and click the Create pull request button, which will open your submitted pull request page as follows.

Creating Merge Request Templates in GitLab

Unlike the GitHub repositories, GitLab allows you to choose from multiple templates in the user interface of the merge request form.

You can see more information on this in the GitLab support docs.

Conclusion

GitHub and GitLab provide a better way to create predefined templates for pull requests. The template options offered by both allow developers to share accurate details of their proposed code changes at the start of the review process. Providing clearer code descriptions makes the code review process easier, which in turn helps achieve better code quality and limits the risks of unnoticed mistakes.

Once you take the time to create pull request templates in your repo, you and your team can utilize them on an ongoing basis when working inside GitKraken—saving you time, decreasing context switching, encouraging consistency, and increasing productivity.

At Axosoft, one of our primary goals is to educate developers around the world about the power of using Git with GitKraken. We can’t be everywhere all the time though, and we don’t know your local tech communities like you do. So, we recently launched the GitKraken Ambassador Program in order to work more closely with professional and student developers globally to teach devs how to be more productive using our tools. We received hundreds of applications from 60 countries, including Azerbaijan to Cuba and beyond.

After carefully evaluating each application, we are proud to welcome our first group of 71 ambassadors from 31 countries including: Australia, Belgium, Brazil, Canada, Columbia, Cyprus, Denmark, Ecuador, England, France, Germany, India, Italy, Japan, Kenya, Latvia, Malaysia, Mexico, The Netherlands, Nigeria, Poland, Russia, Scotland, Singapore, Spain, South Africa, Switzerland, Turkey, Thailand, the United States, and Zambia.

These individuals are passionate about learning, teaching and engaging with their local tech communities. Let’s meet a few! 🤝

Bruno Germano

Location: São Paulo, Brazil

Twitter: @egermano

Based in beautiful Brazil, Bruno has been using GitKraken since the early days. He’s most active on his O Bruno Germano YouTube channel, which touts 57,000 subscribers.

Bruno creates content in Portuguese and focuses on development, including must-have dev tools like GitKraken, Bitcoin, AI, and other tech-related topics.

Josey Howarth

Location: Leeds, England

Twitter: @JoseyHowarth

Fun Fact: Josey is an avid (and fast) reader; she has read 600 books in the last 12 months!

Josey has been a longtime GitKraken user and advocate, with a particular affinity for our Kraken Mascot, Keif. We even created the Keifa Lovelace, based on famed female computer scientist, Ada Lovelace, just for her!

Josey is the Director of Love Sudo, a digital agency helping brands tell their story, and co-hosts DNI (Documentation Not Included), a live stream and podcast about software development on Twitch.

P.S. Check out this DNI episode, Have App Idea, ???, Profit!, featuring GitKraken’s own VP of Product, Hamid Shojaee!

Gatare Libère

Location: Nakuru, Kenya

Twitter: @LibereGatare

Gatare is a natural born leader and teacher, taking it upon himself to share his knowledge of development with many others in his community. As a student at Kabarak University, Gatare is great about sharing GitKraken student resources with his peers.

Gatare is a computer science undergrad specializing in UX/UI design, the Co-Lead of the Developer Student Clubs (DSC) Kabarak University, and enjoys playing volleyball and basketball in his spare time.

Marcin Zajkowski

Location: Prusków, Poland

Twitter: @zajkowskimarcin

Fun Fact: Marcin was formerly a semi-professional basketball player. Alley-oop!

Passionate about open-source, Marcin is extremely active in his local developer community and beyond. He shares his expertise frequently, whether speaking at events, hands-on mentorship and training, or on the #umbraCoffee YouTube channel.

Not only does Marcin excel in development, he also frequently shares his insights on social media marketing. Earning over 4,000 followers on his Instagram, Marcin shares tips on increasing your Instagram audience and mastering social media in his upcoming book, “The Busy Programmer’s Guide to Social Media.”

Also serving as an Umbraco MVP, Marcin knows all too well what being a brand ambassador entails. We look forward to having our GitKraken tutorials translated into Polish! Stay tuned…

Pivendren Naik

Location: Umhlanga, South Africa

Twitter: @ErrorNaik

Fun Fact: Pivendren once did an image recognition session in a banana costume during a DJI drone experiment to identify real bananas from people in banana costumes. 

A frequent speaker at conferences around the world, Pivendren is passionate about sharing his knowledge with other developers and techies. He also serves as a Microsoft MVP and teaches students about development and Git—using GitKraken as the preferred client of course!

We’re looking forward to seeing more photos of Pivendren rocking GitKraken swag as he travels the globe!

Paul O’Brien

Location: Norfolk, England

Twitter: @PaulOBrien

An IT Director by day, Paul boasts an impressive Twitter following of over 34,000. Passionate about mobile, cloud, and Linux, he believes in bridging the gap between technology and humans.

Paul writes frequently on various tech products on his blog; we appreciate his focus on UX, an element we take very seriously here at GitKraken.

Benjamin Mitchinson

Location: Iowa, United States

Twitter: @115bwm

Fun Fact: Ben helped created Computer Comfort at the University of Iowa, where over 100 students share the mission of shrinking the digital divide between generations by educating older adults on today’s technology.

Ben is currently an engineering student at the University of Iowa and already loves giving back to fellow devs.

Serving as both the president of his school’s CS club, Computer Comfort, and mentorship chair of HackIowa, Ben loves connecting with others passionate about software development and gaming.

Join the GitKraken Ambassadors

Are you a professional or student using Git for version control? Do you love using the GitKraken Git Client and Glo Boards to increase your productivity? Are you passionate about learning, creating, and sharing technical content and expertise? Are you community-oriented and enjoy interacting with other techies?

You sound like the perfect fit to join our growing community of GitKraken Ambassadors and GUI advocates! Learn more about the program and how to apply.

Benefits of joining the program include a free GitKraken Pro license, exclusive content, access to our Product Team, swag, and more!

GitKraken Glo Boards is a kanban-style issue tracking system that helps developers and teams collaboratively track tasks. Glo Boards integrate seamlessly with the GitKraken Git Client and can be accessed easily by clicking the board icon in the top-right of the main toolbar. Glo can also be accessed from a web browser, our Android and iOS apps, and from inside Visual Studio Code or Atom.

Since introducing Glo Boards into our GitKraken product line, we’ve been working hard to continuously provide improvements and enhanced functionality. We’ve already accomplished A LOT this year, including the introduction of Teams and Organizations. This functionality offers companies more control over their Glo Boards.

Organizations

Companies that rely on GitKraken Glo Boards often have dozens or even hundreds of boards in their account—each managed by a different user. Prior to introducing the Organizations functionality, account admins had to manually add new team members to every board, and manually remove departing team members from every-single-board they were associated with.

Now, removing a member from an organization automatically removes them from all boards they were associated with.

When a board belongs to an organization, only users from that organization can access the board—providing a new layer of security. It’s no problem to be a member of multiple organizations to manage all those boards in a single account, but you must be invited to an organization if you are not the account owner.

Teams

Time to get your squad together!

Within an organization, it is now possible to create teams by grouping individuals together like ‘Development,’ ‘QA,’ ‘Sales,’ ‘Marketing,’ etc.

After a team has been created and you have selected which users to include, you can then associate teams to boards. This allows for multiple users to be added to (or removed from) boards at the same time!

Better yet, after welcoming a new employee, you can easily add them to multiple boards at the same time by adding them to a team in Glo. This will instantly give them access to every board associated with their team(s) so they can dive right in.

If you have a company board, you can easily set a default team that every new member of your organization automatically gets added to.

#SquadGoals, check!

Board Management

To further improve organization within Glo, our team introduced Board Management, allowing users to designate groups for selected Glo boards.

This can be easily accomplished by dragging-and-dropping boards into a group, and you can edit group details directly from the Glo UI.

Glo Webhooks

Webhooks allow users the ability to create applications which subscribe to Glo Board events. When an event, such as a task assignment or card deletion, occurs in Glo, data from Glo is delivered to the webhook’s URL, triggering an action, such as a notification in another application, like Slack.

A perfect example of this would be if you created an application utilizing a Glo Webhook that posts a Slack message every time a card is deleted from- or added to- a board.

Webhooks can be added in Glo to specific boards by owners and admins. Multiple webhooks can be added to a single board with a GitKraken Pro account.

Glo API Marketplace

After the release of webhooks, we invited developers to submit integrations for a chance to claim up to $10,000 in cash prizes as part of our Glo API Contest. We had some incredible submissions and were thrilled to unveil the Glo Marketplace, which is filled with free applications to enhance your Glo Boards experience.

The Glo Marketplace features Chrome extensions, screenshot tools, IoT integrations, time-tracking tools, voice assistant integrations, Slack extensions, CI/CD integrations, and more.

What is a pull request?

Whether you’re collaborating on a work assignment with colleagues or contributing to an open-source project, chances are that you will be operating in the following scenario. You make local code changes and then submit those changes to a remote project maintainer for review before those changes are implemented, or merged.

This is called a pull request; you are requesting that someone reviews and approves your changes before they become final.

While pull requests are not a core feature of Git, they are commonplace when it comes to collaborating with Git hosting services. They are especially necessary when working with open-source projects.

Let’s say, for example, that you want to contribute to your favorite open-source project in GitHub. Most open-source projects have a maintainer who can control which changes are approved and merged into the project. They have the control to approve and decline changes as they wish.

How do I get changes approved with a pull request?

After forking the repository on the remote hosting service and cloning it to your local machine, you can start working on making changes to the code.

After you’re happy with the changes, you can push the work up to your fork and open a pull request that will signal the main repo. This pull request asks the maintainer(s) to review your work, provide comments, request edits, etc.

If your pull request is approved, the maintainer will merge your changes into the main repo.

How do I use pull requests in GitKraken?

GitKraken supports pull requests from the following Git hosting services:

• GitHub.com & GitHub Enterprise
• GitLab.com & GitLab Self-Hosted
• Bitbucket.org & Bitbucket Server
• Azure DevOps 

After you’ve cloned a repo in GitKraken, it will appear as a remote on the left panel of your workspace.

When you’re ready to submit your changes for approval, you can drag-and-drop your feature branch onto the target branch of the main repo to trigger the pull request option from the dropdown menu. You can also access pull requests by clicking the green + icon on the Pull Requests section on the left panel.

After opening the pull request, fill in the details, like Title, Description, Reviewers, etc. and hit Create Pull Request.

You will see a blue notification bubble in the top right giving you the option to directly open the pull request from the remote service’s page for review.

Not so bad, right?

Why should I use pull request templates?

Many repos have guidelines for submitting pull requests, requiring the inclusion of a description which should clearly describe what the maintainer can expect when reviewing the code and any standards you, as the developer, have considered before submitting the pull request.

Some projects may even require the use of formalized templates in order to submit proposed changes. A template could include a description checklist, requesting details such as:

• How a bug was fixed or summary of a new feature.
• Unit test cases.
• Whether it was tested on all devices and browsers.

How do I use pull request templates in GitKraken?

Accessing and utilizing pull request templates in GitKraken is a breeze.

When creating a new pull request in GitKraken, the Pull Request Template dropdown menu will appear, giving you the option to select a pull request template you’ve created in one of your repos.

You can then fill out the template and submit your pull request from within GitKraken. Easy as that!

Providing the maintainer with concise information and helpful context will give you the best chances of having your pull request approved and merged into the project.

This is a guest blog post by GitKraken Ambassador, Benjamin Daniels. Benjamin works as a Research Analyst for the World Bank Group, specializing in international development economics. His team, DIME Analytics (Development Impact Evaluations), believes in teaching Git, GitHub, and GitKraken to new researchers through a focus on time and task management.

When we heard how Ben and his team were using GitKraken to improve and expedite their work—outside of the software development realm—we wanted to learn more.

Teaching Git and GitHub with a Focus on Task Management

Our team teaches a GitFlow branching model to researchers and other staff who want to better manage their research projects across teams of any size and timeframes of any scale. We do this because research projects are a classic case where the tools of version control with Git, such as GitKraken, really shine; the ability to maintain multiple branches and revisit historical snapshots are very valuable when we are iterating econometric modelling.

However, when we train teams to use Git for the very first time, we don’t teach tools from a technical perspective, but from a task-based perspective. We don’t care as much that our staff understands from the very beginning what is going on behind the scenes, but we want to make sure they can get started and become comfortable using a new technology that will have many unfamiliar aspects.

Making Git Relatable

Our functional model starts from an analogy of a service everyone already knows: email. In our introduction, “Git” is a “protocol” — an invisible thing just like email that runs behind the scenes.

How do you interact with email? Most often, through a desktop client or a webapp. We let GitKraken or GitHub Desktop stand in for the client, and GitHub.com for the webapp (we make sure to pronounce the dot-com to reinforce that distinction). We emphasize that the client interacts well with the work you do on your computer, and the webapp interacts well when you need to coordinate that work with other people.

Understanding Git Terms

We want to make sure users are comfortable making mistakes in these new interfaces, so they feel confident trying new things and asking for help if something goes wrong. Git terminology is frequently not the most encouraging for this: merges are conflicts; tasks are issues; contribution is blame. Similarly, the enormous amount of jargon in the Git documentation can seem impenetrable.

Therefore, we do three things to make Git workflows more accessible when we introduce people to using Git individually.

First, we reduce the functionality of Git to simply committing and branching, and say most other tasks are just complex combinations of these. We give staff the motto “you really can’t break it”; and we ask them to phrase questions in terms of “what they want to do” rather than teaching a great deal of nonessential vocabulary. This provides the most basic onramp into using Git by managing the essential tasks locally in the Git client, GitKraken.

Introducing GitFlow to Economics Research

Our second step is teaching staff to collaborate using Git, by educating them on the following simplified mental model of GitFlow. We focus on relating Git concepts to task management ideas our teams are already familiar with.

The master branch is for executive-level tasks like completing a conference draft or submitting a manuscript.

The develop branch is for project-level tasks, like adding a new figure or table, or writing up a new chapter.

Since code tasks are not done at those levels, we don’t do new work on those branches. We use feature branches to organize the daily work of coding, and each commit should correspond to a sensible human task, like “Add controls to regressions in Table 1.”

Then we show them how pull requests are created and merged on GitHub.com by the person responsible for the higher-level task. The code tasks add up to a project task when a pull request is submitted, and the project tasks eventually add up to an executive task when we prepare a release.

You Don’t Have to be a Computer Scientist to Use Git

The majority of our team members lack computer-science backgrounds; they are mostly highly-trained econometricians, statisticians, survey specialists, or have other backgrounds. The statistical programming tools our teams use on a day-to-day basis do not work like modern webapps or even like regular compiled languages, so code itself is not yet thought of as a primary product. Instead, they tend to hew closer to interactive and scripting languages, and therefore, staff think in terms of what they are trying to do with their code rather than in terms of what they are trying to make.

This model makes that relationship relatively clear, and in doing so provides intuition for some of the most essential technical questions of using Git in practice: “When should I commit?” and “When should I branch and merge?” The answer we used to give was something not much better than “not too often and not too rarely,” but now the answer is more like “when the corresponding task is done,” and this seems to make sense.

This also makes it much easier to introduce people to task management in GitHub and GitKraken Glo Boards, since issues can be directly connected to feature branches, and resolutions of the tasks they contain can be directly connected to individual commits.

Task tracking and code review are two of the main processes we have been able to introduce to our teams without development backgrounds, particularly when senior and managerial staff are often those with the least detailed familiarity of the code base on a given project.

For us at the World Bank Group’s Development Impact Evaluations team, the task-centric method provides a language and an interface for linking code to research analysis work in a way that is relatively easier to understand than, well, this article on distributed workflows; and we hope that this method can be useful to others as well!

DISCLAIMER: The findings, interpretations, and conclusions expressed here are those of the authors alone and do not necessarily represent the views of the World Bank, its executive directors, or the governments they represent.

As founder of Axosoft, there is nothing that excites me more than major new releases of our software, especially updates that affect the productivity of all of our users! On occasion, we also make meaningful pricing changes that make our software more accessible to a greater number of developers worldwide.

Today, we are doing both of these things, which is why I’m doubly excited! We have:

• The release of GitKraken v6.0
• New GitKraken pricing plans

Each is a major milestone, so, let’s jump right in…

GitKraken v6.0: Perf, Perf, Perf… and Tabs!

If it isn’t obvious from the headline, the big focus of GitKraken v6.0 is on performance. With hundreds of feature requests in the GitKraken backlog, it can be hard to stop the entire development team from working on any new features, and instead, focus on rewriting existing functionality to be faster. No new features means our sales team doesn’t get any of the things prospective customers have been asking for. It also means we can’t checkoff any features on customers’ lists of requirements.

When we released GitKraken v5.0 with new functionality like GPG commit signing and interactive rebase, it meant we could go back to customers who had been asking for these features and say, “We did it! Here are the things you asked for.” But no one has been directly asking us to rewrite stuff the product already has.

Why Focus on Perf?

So what was the reason to stop working on new features and focus an entire release on just performance improvements? To understand our motivation behind v6.0, it’s helpful to know Axosoft’s purpose for existing.

We have a company Glo Board that we use to onboard new employees—it also provides useful information about company benefits and policies that every team member has access to. This board starts with defining the two most important aspects of why Axosoft exists: the ‘Why’ and ‘What.’

Axosoft’s purpose since we started the company has always been about making developers more productive so they can ship software on time. This guiding principle has driven Axosoft for more than 17 years; first, in creating the Scrum Project Management tools under the Axosoft brand, and most recently, in the creation of the GitKraken product line. Helping software developers be more productive is the underlying reason for Axosoft’s success.

Since the launch of GitKraken v1.0 in 2016, more than 1.4 million software developers around the world have discovered GitKraken. For hundreds of thousands of them, GitKraken has become a game changer for how they develop software every day because of the productivity gains.

Improving Developer Productivity Benefits the World

If we improve the productivity of those who discover GitKraken by just 1%, given the GitKraken user base, it’s as if we have added 14,000 new programmers to the world’s software development workforce. If we can move the productivity needle by 10%, that’s the equivalent of 140,000 new developers worldwide. 

And those numbers will keep increasing as the GitKraken user base grows. Because we believe software is making a positive difference in the world, having our work be equivalent to adding tens of thousands of software developers to the global workforce is an extremely motivating goal!

With that driving principle to guide us, it makes sense why we wanted to make GitKraken even faster in every possible way. Faster at starting up, faster at opening repos, faster at committing, faster at refreshing the graph and everything else in between. If GitKraken is helping make developers more productive, a faster version of GitKraken will help developers be even more productive! 

We started to look at performance as a feature—a feature that affects 100% of our users! And from there, It. Was. On. The new goal of GitKraken v6.0 was set: it was going to be all about performance improvements.

The GitKraken v6.0 Journey

As we set out on our v6.0 journey, it was important to have some systems in place to provide us with benchmarks.

We spent the first few weeks building the scaffolding that helped us measure everything. We set up canary machines that would automatically test every new build and spit out the performance metrics that we wanted to improve: What was the startup time? Was it on Mac, Linux, and Windows? How many milliseconds did it take to open a repo? What about switching repos? We wanted to make sure we didn’t miss any opportunities for improvement, so, we made perf improvements the mission of the entire team. Every developer had to start thinking about ways to improve speed. 

Once we had our benchmarks and canary machines in place, the hard work could begin. Rewrite after rewrite, shaving milliseconds off of each operation, the team was hyper-focused on performance—paying attention to every little detail. Slow JavaScript code that took 100ms to execute was re-written in C++ so it could run in 10ms; operations that were redundant were eliminated; and major parts of GitKraken were re-worked to make it faster.

Rebuilding from the Inside Out

At first, it felt like chaos. It was like we were doing knee surgery and brain surgery while also performing a heart transplant. We were taking out the guts of GitKraken, and with every surgical removal, we were putting in new untested parts.

Like most large software projects, sometimes you have to embrace the chaos and the lack of visibility, pushing forward every day. Even though we couldn’t see the results at first, we knew we were headed in the right direction. Each part was being replaced with a faster, shinier version.

Over and over again, part by part, the replacements were happening at a feverish pace. Finally, after months of work, GitKraken was being put together again, and the light at the end of the tunnel started to emerge.

We were finally at a point where all the pieces were coming back together—we had a build! When we opened GitKraken for the first time after surgery, our familiar spinning Kraken mascot, Keif, started his dance, but then after just two spins, he abruptly stopped. Damn! I thought to myself, as I sat there wondering what had gone wrong. Keif normally does his dance for six full spins. After months of work, the last thing I was expecting was for the application to crash on open. But within a fraction of a second, the beautiful guitar-hero-like commit graph emerged. “Wait, what just happened?” I asked the team. “Was GitKraken already running on this machine? Surely this could not have been a fresh load of the product!”

GitKraken was not already running. The team informed me this was a fresh load! These were in fact the startling results of months of intensive surgery. GitKraken was whole again, and the results were fantastic. It wasn’t just opening faster, everything was faster!

Here is a chart showing the improved times of GitKraken v6 compared to v5:

While we were excited about these results, we also realized that these improvements came at a cost. Our beloved dancing Keif was being cut off after just two spins. Like many of you, I was going to miss our little guy’s dance moves. Two spins wasn’t going to be enough for me. Each time I opened GitKraken, a smile would come to my face as I watched Keif dance around my screen.

Fortunately, our marketing team had a solution for me. I can now visit the Keif Gallery anytime I want to see Keif dance!

And Then There Were Tabs…

As we continued to measure and improve GitKraken’s performance for virtually every operation, something occurred to our team during one of our review meetings: what if we used these perf improvements to allow rapid switching of repos, in the form of tabs?

The idea of tabs was nothing new, but because GitKraken has a relatively large footprint and can be a little memory-hungry due to its visual nature, opening lots of repos at the same time could get very costly. However, with all the perf improvements, the idea was to implement tabs in a highly efficient way.

Instead of loading all the goodness of GitKraken–including its graph and all of the underlying infrastructure–we thought, ‘what if we provide a fast means of switching between repos that provides all the benefits of tabs, but with little overhead?’ If we could rapidly load a new repo and show the graph, there would be no need to keep everything in memory – we could cache the important stuff and rebuild the rest quickly.

The idea of having a handful of frequently used repos accessible in the form of tabs was super exciting. So while most of our developers were continuing to finish out the performance improvements of GitKraken v6.0, we put a couple of team members on testing out a prototype of tabs— just to see if people would like it.

It turned out everyone loved tabs! Once people started using tabs, nobody wanted to give them up.

Some felt that between the perf improvements and tabs, tabs was the bigger deal in v6.0. As a result, tabs became the major unplanned feature of the release. Go figure. We didn’t set out with the intent of having any new features in v6.0, and by doing so, the perf improvements enabled what could be one of the most important features that will affect every user’s workflow: tabs!

GitKraken Pricing Changes

With the release of v6.0, we also wanted to improve GitKraken’s pricing plans.

Our intent has always been to offer GitKraken free of charge for students and those working on open-source projects. Since the inception of the product, we’ve always had a free version that has been described as “free for non-commercial use.” However, this terminology was a little vague and sometimes lead to confusion. Does “free for non-commercial use” mean you can use it at a government organization for free? What about for personal use on projects you’re getting paid for? The questions were endless.

Free Git Client for Public Repos

So we decided to eliminate the confusion in this way:

• The free version of GitKraken can only open public repos
• For anything else, you need a paid version

This allows GitKraken’s free version to be used for open-source projects. It also allows the free version to be used commercially—as long as it’s on public repos.

Additionally, students get GitKraken Pro free as part of the GitHub Student Developer Pack. Therefore, this new pricing strategy addresses our original intent in a much less ambiguous way.

Git Client Pricing for Individuals

However, we also recognize that there are a lot of GitKraken users that want to use our product for their own side projects—many of whom have private repos. For these individual users, who may cash strapped, we wanted to lower the pricing barrier so that it’s a non-issue.

At $49 per user per year, GitKraken Pro is already the least expensive Git client on the market, but for individual users, we are reducing the barrier even further. Which is why we’ve introduced a new plan that’s only  $29 per year for individuals! And we’re sweetening the deal by throwing in the Merge Conflict Editor.

So for less than $2.42 per month, anyone can purchase GitKraken and use it however they want: for personal use, for commercial use, for non-profit work… whatever! Just do good with it.

What about Glo Boards?

Up until now, our Glo Boards task and issue tracker has been free only for non-commercial use. As of today, we are changing that: Glo is now free for commercial or non-commercial use!

But as we continue to build more features into Glo Boards, we are providing new, additional functionality for Glo users in each of the GitKraken paid plans. For example, in the new GitKraken Individual plan, you also get access to the new custom board backgrounds feature!

What about GitKraken Pro Users?

If you are a GitKraken Pro user, don’t worry, as the Pro subscription is still the best GitKraken subscription to have. There are features that are exclusive to Pro users.

For instance, multiple GitKraken profiles, which have been enhanced to remember your tabs, are only found in GitKraken Pro. When you switch profiles, say between Work and Home projects, GitKraken will reconfigure your tabs exactly the way you left it when you were in that profile. The ability to access self-hosted installations of GitHub, GitLab, and Bitbucket are also features exclusively available to GitKraken Pro customers. Additionally, the ability to manage an organization, its GitKraken users (and their licenses), as well as the ability to define and use the teams functionality in Glo Boards, are all features that require a Pro subscription.

In short, if any of the Pro-only features appeal to you, or if you are purchasing more than one license, you’ll still need GitKraken Pro.

GitKraken Pricing Comparison

To summarize, this is what the new GitKraken pricing plans look like:

There are more than 30 million Git users worldwide. We believe all of these users deserve to be more productive by using GitKraken, and think our new pricing plans help put our tools in reach for more software developers worldwide. We hope you’ll join us on our journey to reach 10 million GitKraken users and beyond!

We’ve been cooking up some stranger things to make your issue-tracking experience even more productive and, dare we say…fun? This latest release includes some extremely exciting additions to developers’ favorite kanban tool: GitKraken Glo Boards! 

Grab your flashlight, and let’s explore public boards, global search, card cover images and new board backgrounds. 

Public Boards

Eleven may have closed the gate, but Glo is still getting out into the world with public boards! 

If you’re a board owner or admin, you may change the board’s visibility by clicking the gear symbol at the top right of your Glo UI, and hit Board Visibility to make your board public. 

You can select from the following visibility options:

• Private: only board members can access and view the board.
• Organization: anyone who is a member of the related organization can view the board. (Pro only feature)
• Public: anyone with the link can view the board. 

If you choose to make your board public, a PUBLIC badge will appear next to your board name in blue. 

One of our favorite things about this new feature is that GitHub-synced boards can also be made public—giving you the push you’ve been waiting for to share your projects with the world!

Similar to sharing View Only files via Google Drive, anyone who has a board URL can view the board, but they do not have permission to edit.

Cover Images for Cards

Smile for Jonathan Byers’ camera! You can now set cover images for Glo cards. 

Card cover images allow you and your team to quickly scan your boards and see which cards contain information pertaining to specific bugs, features, etc. 

Simply drag-and-drop an image directly on top of a card to set the image. Alternatively,  attach the image as a file, scroll down to the Files & Images section in card details, and click Set Cover Image. Similarly, when you want to remove the image, scroll to the same section and click Remove Cover Image. File types supported include .jpeg, .png, .gif, and .bmp. 

Global Search 

We know, with all of these visual changes, it might feel like your world has turned upside down. But fear not, global search will help shed some light so you can escape the demogorgon! 

Global search allows you to search and filter through all of your cards and boards in Glo. If you frequently work in multiple boards, or if you need to search for a specific card and find it quickly, this new feature will be a huge time-saver!

Simply use  the search bar at the top of Glo, or access the search bar via the Cmd/Ctrl + K keyboard shortcut. 

More Board Backgrounds 

We hope you’ve been enjoying one of Glo’s other recently released features: custom background images. Our team is digging them so much that we’ve created even more options for you to choose from.  Enjoy newly added backgrounds for Lunar New Year, Pride, Smash Bros. Ultimate, and more. 

Whether you’re into Eggo’s, Dungeons & Dragons, or Christmas lights, board backgrounds are perfect for showing off your Glo-style. 

We’ve all been there. Whether you were multitasking or just simply selected the wrong working branch, there has likely been a time that you wanted to save your file changes but you weren’t quite ready to commit them. 

Enter stashing. Stashing is a Git function that allows you to temporarily save your file changes without applying them to your project. This can be especially helpful when collaborating with others, giving you more time to perfect your changes before sharing. 

What is Stashing?

In this article—and in the latest Git tutorial video in our Learning Git with GitKraken series—we’ll answer the question ‘What is stashing?,’ and show you how to use the GitKraken Git Client to quickly and easily stash your changes.

Managing Distractions and Mistakes 

In most cases, when you edit, add, or delete a file in your working repository, you would stage and then commit those changes to apply them to your project. 

But let’s say, for instance, that your team lead asks you to review another branch…like Right. Now. Your attention is diverted and you must switch branches (hurry!!), but you’re not ready to commit your changes (ah! panic sets in…). 

Or, worse yet, you’ve been working on the wrong branch entirely (Son of a!). You don’t want to lose your work, but you can’t apply the changes to the branch currently checked out (cue sobbing at your desk). 

These are two common developer situations where stashing can save the day. When you create a stash, you are saving uncommitted changes so that you can work on other things without losing your changes. 

Stashing: Apply vs Pop

When you’re ready to finalize these saved changes, you have two options: apply or pop. 

Apply will take the stashed changes, apply them to your working directory, and keep the changes saved as a stash. 

Pop will do the exact same thing for the first two steps, but it will permanently delete the stash. 

A Word of Caution

While stashing can play a helpful role in temporarily saving files for later access, it is not a substitute for committing changes. 

Our team also suggests, as a best practice, to use stashing in moderation. If you are constantly utilizing this feature, you will likely lose track of which saved changes are where, making your project increasingly chaotic. 

Stashing in GitKraken 

GitKraken makes stashing file changes extremely easy and clear, helping you avoid mistakes and ensuring you’re committing files to the appropriate branch. 

Let’s take the following example: You’ve checked out a feature branch and are making changes to multiple files. Gulp… You just realized you checked out the wrong branch. 

To give your future self some context, we suggest naming the stash, which can be done easily by simply typing in the text field next to the WIP node at the top of your commit graph. 

After naming your stash, click the Stash button on the top toolbar inside of GitKraken. Your stashed changes will now appear at the top of your graph as WIP on [insert branch name]: [insert stash name]. 

Let’s say we want to pop this stash. Double-click to check out the correct branch where you wish to see your changes reflected, and click the Pop icon in the GitKraken toolbar. This will apply the changes you stashed onto the correct branch and then delete your stash.

From here, you can stage and commit your changes. 

Alternatively, if you wish to apply the stash, you can right-click directly on the stash to access this option in GitKraken. Performing this action will apply the stashed changes onto the correct branch, but will also keep the stash intact. 

When done correctly, the stash function can be a real lifesaver. And thankfully, the GitKraken Git Client makes it intuitive and clean so you can keep your project organized to more effectively collaborate with your team. 

With the recent announcement of the update to GitHub Actions, we are excited to announce support for GitHub Actions in both the GitKraken Git Client and Glo Boards for task tracking. 

If you haven’t seen it yet, here is the GitHub announcement about the GitHub Actions update:

What is GitHub Actions?

GitHub Actions is a cloud service that you can use to automatically build and test your code projects and make it available to other users. It works with just about any language or project type.

GitHub Actions combines continuous integration and continuous delivery (CI/CD) to constantly and consistently test and build your code and ship it to any target.

You can also use Actions from the GitHub Actions Marketplace to create automation and workflows to perform virtually any action based on various triggers.

In the rest of this blog post, we’ll explain how GitKraken and Glo Boards are supporting GitHub Actions.

GitKraken Support

Create and Manage GitHub Action Workflows 

Workflows in the GitHub Actions service run actions that build, test, and deploy your code. They exist as .yml files inside the .github/workflows directory in your repository. The GitHub Actions integration helps you easily create and manage these workflow files right inside the GitKraken Git Client.

A new GitHub Actions section has been added to the left panel in GitKraken that will be displayed for repositories with an upstream remote on GitHub, or when a repository contains the .github/workflows directory. This section will display any existing workflow files on the currently-checked-out branch of your repository, and provides quick access to view and edit those files with GitKraken’s built-in editor.

You can create a new workflow in GitKraken by clicking the green Create Workflow button.

From here, you can select an optional template, or start your own workflow from scratch.

Newly-created workflow files will immediately open in GitKraken’s file editor where you can review, modify, and save changes. Simply stage the workflow file in the commit panel, and commit to see it appear along with the other workflows in the left panel.

Push your changes to GitHub and your new workflow is ready to be used by the GitHub Actions service!

Glo Support

Automate Card Updates

We are excited to announce the immediate availability of GitHub Actions for Glo Boards. You can now automate the manipulation of cards on your Glo Boards using GitHub Actions. We have initially released six GitHub Actions for you to use in your repository workflows. For a full list of Actions and more information, refer to https://github.com/Axosoft/glo-actions/. For now, the example below can get you started. 

Example: Move linked Glo cards to the Deployed column when a PR is merged on GitHub.

Create a Personal Access Token (PAT) in your GitKraken account. Actions will need read/write access only.

2. Add the Access Token for the PAT as the value for a secret in your repository settings on GitHub.

3. Set up a workflow for your repository on GitHub that will trigger the necessary Actions (you will add the secret name as the authToken). 

4. Add a link to your Glo card in your PR description. 

That’s it! The Actions will now automatically update the linked Glo card from your Pull Request. 

There are many reasons to conduct a student hackathon, whether you’re a student, teacher, or community advocate, these events help stimulate technical growth, exploration, collaboration, and creativity. 

But taking on the efforts of planning and executing a hackathon is no small task. These events typically last multiple days, involve lots of moving parts, and require numerous technical tools and expertise. You will need a strong team and the right equipment to create a valuable experience for attendees. 

In this article, not only will we recommend software tools and a roadmap for running a successful student hackathon, we will also include insider tips from our partners at Major League Hacking, and ProTips from GitKraken Ambassadors who have successfully hosted many hackathons (and lived to tell the tale!). 

In this article, you will find: 

1. Recommended Software Tools for Student Hackathons
2. Steps for Planning a Successful Hackathon
   1. Building Your Team
   2. Finding a Venue
   3. Hackathon Timeline
   4. Budget & Sponsorships
   5. Selecting Judges
   6. Promoting Your Hackathon

Best Software Tools for Student Hackathons

Throughout your event, you’re going to be asking attendees to complete a software development project, and they are going to need the right tools to get the job done. 

GitHub has partnered with companies like Axosoft to offer not only their open-source hosting platform free for students, but other leading tools like the GitKraken Git Client, Glo Boards, Digital Ocean, Atom, AWS and more, for free via the GitHub Student Developer Pack. 

1️⃣Glo Boards

Glo Boards is a tool for tracking  tasks and issues designed specifically for developers. Users can create colorful kanban boards to view their tasks in a workflow with columns or a calendar view. 

The best part is how easy Glo makes it for teams to collaborate. You can create task cards and assign them to team members, and see how far along everyone is on their portion of the project. 

Glo is a completely free tool your attendees can continue using after the hackathon to help organize tasks for other classes or home projects. Time management and organization are crucial skills for the workplace, and many student developers don’t take the time to practice while in school. Plus, if you join an organization using Glo with GitHub, you’ll get even more out of the tool with real-time GitHub Issue sync.

2️⃣GitKraken Git Client 

Glo Boards integrate directly with our next recommended tool, the GitKraken Git Client, decreasing context switching and preventing your attendees from having to create yet another account. 

Students can receive GitKraken Pro licenses FREE through the GitHub Student Developer Pack. This allows your attendees to access advanced features—like the in-app code editor and merge conflict tool—and they can utilize the tool free as long as they’re enrolled. 

Hackathon attendees can use this tool to create, manage, and track changes made to their projects. It makes collaborating on development projects a dream. Whether you’re new to Git or an advanced user, GitKraken provides a visual roadmap of your entire project, including who made which changes to what part. 

GitKraken’s beautiful UI, intuitive drag-and-drop functionality, and robust search capabilities are some of the elements that make this tool perfect for a broad range of experience levels.

3️⃣Major League Hacking 

Deciding which content you want to present at your hackathon is at least half the battle. And Major League Hacking (MLH) makes this process so easy!

While MLH helps facilitate student hackathons with partners across North America, they also have an extensive library of turnkey, ready-to-go workshops covering a wide variety of development topics. There’s even a workshop on how to get started with Git using GitKraken! 

From the MLH website, hopeful hackathon organizers can sign up as a workshop organizer through their MLH Localhost Program. 

The MLH Localhost library includes workshops on topics and tools like Slack, Microsoft Azure, Google, Docker, GitKraken, and more. 

4️⃣Other Equipment 

You will also need some basic equipment to help ensure a successful event:

• A projector
• WiFi strong enough to ensure quality connection for all attendees (you may even want to bring extra routers) 
• Power strips
• Extra cables, cords, adapters, and USB drives

Generally, hackathon attendees are expected to bring their own personal computers. This should be clearly communicated in the event promotion.

Planning a Successful Student Hackathon 

Now that you have your toolbelt ready to go, it’s time to pull a team together and start planning event logistics. 

1️⃣Build a Team

First thing’s first: get your squad together! If you’re reading this article, it’s likely you’re a natural born leader. We get it. But even the best leaders need help, and for an event of this magnitude, you just can’t do it alone. You’re going to need a team. 

You will want volunteers who can not only help you plan the event and secure sponsors, but also volunteers to assist onsite when the time comes (setting up food, checking-in attendees, directing people where to go, etc). Furthermore, you will want to secure a handful of volunteer mentors who can offer advice throughout the duration of the hackathon. 

The team at MLH has more expert advice to share on building a killer leadership team in their Hackathon Organizer Guide, which is a wealth of knowledge you can refer back to throughout your planning process. 

2️⃣Select a Venue

Before you can do much else, you need to find a venue. Selecting a space for a hackathon is significantly more difficult than finding a venue for a workshop or networking event.

You will need space for a large group to gather for both the opening and closing activities, and you will also need areas for teams to breakout and work together for hours on end. Furthermore, you will need spaces to serve food and beverages throughout the day.

In addition to the physical space, you will also need seating. Each attendee should have a place to sit, and ideally a tabletop to place their laptop. 

Not all hackathons involve overnight sleeping options, but some do for multi-day events. If this is something you’re considering, you will also need to find a quiet, dark area for attendees to rest.

3️⃣Determine the Format and Timeline for Your Hackathon 

The MLH Hackathon Organizer Guide does a wonderful job of outlining the entire planning process in a 9-month timeline, detailing at what point in the process you should be accomplishing specific tasks. Refer back to this resource to ensure you’re on track leading up to your event. 

Some student hackathon organizers choose to set a theme to encourage certain types of projects, like applications focused on environmental or societal change for example. While you don’t necessarily need a theme, you will need to provide your attendees with a good amount of direction during the opening event before releasing them into working groups. 

Traditionally, a hackathon timeline will look something like this: 

Day 1 (half day) 

• Welcome Attendees. Hackathon organizers give an introduction to the event, share information on partners and sponsors, and cover any housekeeping items (where the bathrooms are, where to get coffee, etc). 

• Open Pitches. Hackathon attendees are invited to pitch an application idea to the larger group. These ideas are then voted on to select the most popular ideas, which will eventually be built during the hackathon by working groups over the next two days. 

• Breakup into Working Groups. Typically, attendees are invited to decide which idea they want to work on. Roles within each group are determined based upon need and expertise. Whoever had the original project idea will naturally take a leadership role and may delegate based upon their vision. 
• The Work Begins! Groups are now expected to begin work on their project. You may consider offering a meal to close the night or providing suggestions for where attendees can find food options. You should also let them know which hours they can access the venue’s working spaces.

Day 2 (full day) 

• Demo Software Tools. The start of day 2 is typically a good time to review the tools students can access and how to use them. To minimize an overload of information, 5-10 min demos are recommended. 
• Work, Work, Work. Attendees are expected to get the bulk of their project completed on day 2 to prepare for judging on the final day. 

Day 3 (half day) 

• Final Project Touches & Mentor Check-Ins. Attendees are usually afforded an hour or two at the start of day 3 to put finishing touches on their project, and are also welcomed to practice their pitch in front of mentor volunteers. 
• Final Pitches. Teams present their pitches to the larger group and a panel of judges. 
• Announce Winners & Closing Celebrations. After the judges are able to deliberate, hackathon organizers will announce the top 3 winners. A closing celebration to culminate the event is a nice touch. 

4️⃣Devise a Budget & Solicit Sponsors

Two things will help you determine how many attendees you are able to support at your student hackathon: the venue and the budget. 

If you’re lucky, you can find a venue sponsor who will offer their space in-kind (free of charge in exchange for sponsorship benefits). Otherwise, this will likely be the largest expense. Depending on how many people you are hoping to host and the length of your event, venue fees can range anywhere from a few hundred dollars to over $10,000. It’s critical that you keep an eye out for hidden fees often associated with venue rentals, like labor, cleanup, AV charges, etc.

Food and beverage is going to be the next line item that sucks up a large chunk of your budget, and here is where in-kind sponsors can come in handy. Even if you’re expecting attendees to source their own meals offsite, you will want to have plenty of snacks, and, most importantly, caffeine, to keep your attendees energized throughout the course of your event. 

Finally, sponsors can be a great way to source prizes for your top 3 winners. Whether it’s cash, swag, gift cards, etc, prizes help improve the quality of the work completed at your hackathon, and will attract more students to attend.

Checkout this great MLH reference on putting together a sponsorship prospectus. 

5️⃣Pick Judges

Unless your hackathon has a theme requiring specific expertise, you will want to select a diverse panel of judges with technical knowledge, who can provide advice on securing investors. In many cases, the judges will be investors themselves (and who knows, they may find their next investment at your event!).

Get more tips on booking hackathon judges, like where to source them and how best to ask, in the MLH Hackathon Organizer Guide. 

Your judges will be a crucial element of your event, so be sure to provide as much advance notice as possible when you ask them to be involved. Professionals often have busy schedules, after all! You will also want to give them extremely clear instructions of where and when they need to be on day 3 for judging. 

6️⃣Start Promoting Your Hackathon 

After you have all your plans in place, or maybe even before, you’ll want to start promoting your event across your school. Targeting student groups like the software developers association, computer science classes, or other tech-based organizations, is a great way to start. You may also consider inviting local tech bootcamps or other nearby schools. 

Spread the word even further by asking your team, sponsors, and partners to reach out to their personal networks. 

After attendees register for your hackathon, it’s extremely important that they have a comprehensive understanding of expectations: they need to bring a computer, they have to attend all three days and be present at all events, etc. 

For more tips and tricks for attracting attendees to your hackathon, check out the section in the MLH guide on promotion. 

In the End, It Should be Fun 

Our final piece of advice comes from GitKraken Ambassador Gatare Libère from Nakuru, Kenya: “Make it fun!”

At the end of the day, your hackathon should be a fun experience for you, the attendees, judges, mentors, and volunteers alike. Consider mixing up the work hours with short activities like stretching, group games, a coloring break—get creative! 

Now, go forth and hack! 

Like all of our legendary GitKraken dev tools, Glo Boards is specifically designed to make developers and teams more productive. While Glo has always made it fast and easy to manage tasks and issues, we’ve taken it one step further. 

According to the 2019 State of Software Development Report by Coding Sans, more than half of development teams worldwide are using Slack to communicate during a project. 

While Slack is an incredible tool for communication, on its own, it’s not a convenient tool for project or task management. Enter Glo Boards for Slack. 

Slack Integration for Glo Boards 

While Glo Boards has always made it convenient to track and manage issues via a browser, Visual Studio Code, the GitKraken Git Client, Atom or the Glo mobile apps, our Slack integration gives users even more power to update tasks on the fly. 

With Glo Boards for Slack, users are able to: 

• Create Glo cards from Slack 
• Use card links to generate card previews in Slack 
• Update card assignees, labels, and the column of a card you’re currently viewing in Slack. 

Create Glo Cards from Slack 

Users can easily create Glo cards in Slack using /createcard, noting the desired card name following the slash command. 

Your card details will preview in Slack, allowing you to then select which Glo board and column you want this new card to appear on. Click the Create Card button and voila! You can immediately see your new Glo card appear in the desired location in Glo. 

Render Glo Cards in Slack 

After using the /createcard command, the integration immediately generates the URL for the new card and unfurls it at a visual card preview directly in Slack. How cool is that?! 

Additionally, you are given the option to edit card details from Slack, including labels, assignees, and designated column. Any details that are adjusted from Slack are immediately reflected in Glo Boards. 

To recap (because this functionality is actually pretty unique and impressive): we not only show you an exact visual replication of the card in Slack, but when you add/delete a label or assignee, the image itself will update, both in Slack and on the actual card in Glo Boards. 

Cue slow clap… 

Generate Card Previews in Slack

Posting a Glo card’s URL in Slack will now unfurl to include a preview of the Glo card, showing you a visual replication of the card, including the cover image, the card’s description, and task list. 

Furthermore, card links will generate the option to edit card details such as labels, assignees, and designated column. Again, any details adjusted in Slack will be updated in realtime directly in Glo Boards. 

On card previews, users can: 

• Click the card name or View Card button to access the card in Glo
• Toggle and adjust card labels using the Labels dropdown 
• Toggle and adjust card assignees using the Assignees dropdown 
• Adjust the designated column of the card using the Column dropdown

Installing Glo Boards for Slack 

Installing Glo Boards for Slack is quick and painless. You can start by either clicking the button below, or by simply typing the /createcard command into Slack, and Slackbot will direct you to complete the install process. 

The Slack app installation portal gives you the opportunity to review requested permissions before clicking the Installbutton. 

You will then be redirected to your GitKraken login where you can review additional permissions and authorize the application. 

After clicking the Authorize button, you will be redirected back to Slack where you can start using the integration! 

Update Tasks in Realtime Using Slack

Glo Boards for Slack now makes it possible to use your favorite team communication tool to stay on track of project tasks and upcoming deadlines, and it adds even more flexibility and convenience to your favorite project management tool, Glo Boards. 

At first, learning software development can feel like being lost in a maze…like the weird, scary maze from the Labyrinth. 

You’re learning languages upon languages, equations and variables, time management and organization – it’s madness I tell you, madness!! 

But fear not! Learning software development in 2019 means that you have numerous tools at your disposal to help ease the transition from normal human to coding master. 

And the best part?! Many of these products, including GitKraken, are FREE for students through the GitHub Student Developer Pack. 

We asked our community, including our GitKraken Ambassadors in the education space, to share which tools they recommend for student developers. 

Here are the top 5 developer tools for students: 

1. GitKraken
2. GitHub
3. Visual Studio Code Editor
4. Slack
5. Glo Boards

1️⃣ GitKraken 

Learning Git as a student can set you apart from your classmates and will make you more attractive to prospective employers.

Learning the fundamentals of Git, a robust and complex version control system (VCS), as a student will enable you to quickly jump in and collaborate with future colleagues when you join your first development team. 

Something notoriously difficult about learning Git is visualizing what’s happening under the hood, as the command line interface can be extremely cryptic. GitKraken’s UI is the best on the market, offering a great deal of visibility into all aspects of your project, including branches and commits. 

See how how different commit history looks in GitKraken vs the command line in this article: The GitKraken Git GUI vs the CLI.  

The best part?! Students can get GitKraken Pro for free through the GitHub Student Developer pack, which includes our in-app code editor, allowing you to create and edit files directly in GitKraken. 

2️⃣ GitHub

GitHub is a Git repository hosting service used by millions of developers worldwide who utilize Git for version control on their coding projects. 

The 2019 State of Software Development Report by Coding Sans shows that over 91% of organizations polled are using Git for version control, with 34.53% using GitHub for project management. Having an understanding of this tool will better prepare you for entering the workforce. 

Alexey goes on to outline various ways educators can use GitHub, including tracking student progress, collecting students assignments, encouraging in-class participation, and more. 

GitHub has done an incredible job of supporting both students and teachers alike through the GitHub Education initiative. Students can receive free developer tools through the GitHub Student Developer Pack, apply to become a GitHub Campus Expert, seek funding for student hackathons, host GitHub workshops through MLH Localhost, and work to become a GitHub intern. 

3️⃣ Visual Studio Code Editor

Some of the elements developers love about GitKraken are also present in Visual Studio Code, a code editor by Microsoft. Offering an intuitive UI with a prominent sidebar, powerful defaults, discoverable extensions, and more, VS Code provides a simple and clean code editing platform for student developers. 

VS Code users appreciate the ability to organize files by folder or project; there is also smart editing for built-in languages like JavaScript and Typescript, which can come in handy for students who are constantly being introduced to new coding languages. 

4️⃣ Slack 

Slack, the increasingly popular communication tool, is used by teams and corporations worldwide. Not only will gaining experience using Slack help students adapt to your future workplace, but there are countless communities within the application for students to join to share and obtain information. 

The GitKraken Slack Community, for example, offers channels for asking support questions, communicating with other users, and submitting feature requests with our product team. We even have an off-topic channel where users share personal interests, humorous memes, and more viral content. 

Are you a member of a local dev meetup or your school’s computer science club? Do you volunteer at a tech-based nonprofit? It’s common for groups like these to have community Slack channels. 

There are also communities for specialities within the tech industry, like this one for iOS developers. 

With many online forums, Slack is a great way to meet other like-minded people, share helpful information, and support each other. Be sure to read and respect each community’s Code of Conduct. 

5️⃣ Glo Boards 

Offering seamless integration with our number one tool, GitKraken, Glo Boards provide a platform to track tasks and issues across projects. Task management is often not a prioritized skill for students, despite the fact that it can make or break you in the workplace. Taking the time to practice issue tracking and time management now will serve you well in the years to come, and will set you apart from the pack. 

Glo Boards make it easy to collaborate with teammates and see what action items need to get done. Students can assign tasks to other team members and track those tasks to completion. You can even create and share public Glo Boards with classmates who don’t have a GitKraken account—all you need is a URL! 

Better yet, Glo can be accessed via a mobile app, making it convenient to organize to-do items for all your classes, and even personal projects or inspiration boards, while at your computer or on the go. This incredible tool is free for all!

Become a Better Developer with GiKraken 

GitKraken has helped thousands of students globally learn Git and reach their potential as software developers. Join the movement and get GitKraken Pro free through the GitHub Student Developer Pack to level up your game, impress classmates, and land that future dream job. 

Since the inception of Glo Boards for task and issue tracking, the GitKraken team has continued to add robust features that allow developers to be more productive. And our latest addition is no different. GitKraken Glo Boards now supports linking GitHub pull requests with Glo cards.

This feature will allow users to check the status of a pull request and automate moving a card into a new column based on whether a pull request has been opened, closed, or merged.

Integrating GitHub Pull Requests with Glo Boards 

The first step is setting up the integration. Login to Glo Boards, and then click on the gear icon at the top of the Glo UI to access the Pull Requests option. Then hit the Connect to GitHub button. 

Once connected to GitHub, select the repo(s) you want to connect to Glo Boards. You will be able to choose from a dropdown menu populated with your GitHub hosted repos, and you can connect to as many repos as you wish. 

From here, you can map out your automation process. Select which column you want a card to be moved to when a pull request is:

• Opened
• Closed & Merged
• Closed
• Merged

Now, your integration is ready to go! 

Tracking Pull Request Statuses in Glo Boards 

After setting up the integration, you will want to start linking Glo cards to your GitHub pull requests. Do so by accessing the Pull Request section on a card’s details. This section populates a dropdown menu of your linked pull requests; simply click on a pull request from this list to link it to the card you’re currently viewing.

After linking the pull request to your card, it will appear in your card’s Pull Request section as an item with a corresponding label. The label will note the status of the pull request (i.e. Open). You may also quickly view available pull request information like name, ID#, date last opened, and build status.

Click on the pull request name from your Glo card to open it in GitHub.

Unlinking a pull request from a Glo Card is a cinch. Simply click the X icon on the top right.

Pull Request Automation in Glo Boards 

Here’s the real magic: when a pull request status is updated in GitHub, the Glo card will automatically advance to another column based on the mapping you set up during the initial integration. 

That’s right. No more time lost searching through your various cards and pull requests, or manually reorganizing your Glo board. 

Link Glo Cards When Creating Pull Requests

When you’re creating a new pull request in either GitKraken or GitHub, you can link a Glo card to the pull request by pasting the card’s URL into the pull request description. 

Alternatively, you may edit the description of an existing pull request to add a Glo card’s URL.  

Pretty phenomenal, right?! 

It’s no surprise to learn that the team at GitKraken is passionate about Git. So passionate, in fact, that we created an educational database featuring our Learning Git with GitKraken YouTube series, educational white papers, cheat sheets, and more. 

And our partners at Syncfusion are no different. In a previous article, Bharat Dwarkani, technical product manager at Syncfusion, describes how the Gitflow model has simplified his organization’s development and release processes. In this post, he shares guidelines for implementing and successfully utilizing Git. 

Guidelines for Git Fundamentals

At Syncfusion, we’ve been using the Git workflow to manage complex products across a variety of products. However, to successfully collaborate with team members using Git, it’s important for everyone to be on the same page regarding how best to utilize version control for their specific use cases. Here is a list of dos and don’ts to help you navigate Git. 

Git Dos

• Create a Git repository for every new project.

• Always create a new branch for every new feature and bug.
• Regularly commit and push changes to the remote branch to avoid loss of work.
• Include a gitignore file in your project to avoid unwanted files being committed.
• Always commit changes with a concise and useful commit message. 
• Utilize git-submodule for large projects.
• Keep your branch up to date with development branches.
• Follow a workflow like Gitflow. There are many workflows available, so choose the one that best suits your needs.
• Always create a pull request for merging changes from one branch to another.

• Always create one pull request addressing one issue.
• Always review your code once by yourself before creating a pull request.
• Have more than one person review a pull request. It’s not necessary, but is a best practice.
• Enforce standards by using pull request templates and adding continuous integrations.

• Merge changes from the release branch to master after each release.
• Tag the master sources after every release.
• Delete branches if a feature or bug fix is merged to its intended branches and the branch is no longer required.
• Automate general workflow checks using Git hooks.

• Include read/write permission access control to repositories to prevent unauthorized access.
• Add protection for special branches like master and development to safeguard against accidental deletion.

Git Don’ts

• Don’t commit directly to the master or development branches.
• Don’t hold up work by not committing local branch changes to remote branches.
• Never commit application secrets in public repositories.
• Don’t commit large files in the repository. This will increase the size of the repository. Use Git LFS for large files. 

• Don’t create one pull request addressing multiple issues.
• Don’t work on multiple issues in the same branch. If a feature is dropped, it will be difficult to revert changes.
• Don’t reset a branch without committing/stashing your changes. If you do so, your changes will be lost.
• Don’t do a force push until you’re extremely comfortable performing this action.
• Don’t modify or delete public history. 

Considering the previously listed dos and don’ts will help you use Git more effectively. But keep in mind, even Git experts like us are always learning and expanding our knowledge. And the good news is that Git clients like GitKraken are transforming the way developers interact with Git, making the process easier and your Git workflow more intuitive. 

GitKraken issue boards are designed to make developers more successful with intuitive project management and issue tracking. 

Features like Slack integration and GitHub pull request linking are just two recent examples of how the GitKraken team is constantly updating this product to enhance productivity and organization for individual developers and teams. 

Our latest Glo Boards release is no different; we bring you dashboards and milestones! 

View Activity with Dashboards 

Get a bird’s-eye view of all boards designated to a board group, including an activity tracker showing card count per column. 

On the left board panel, simply expand the dropdown from any board group to see the dashboard option. Click Dashboard to see all boards from that group populate as a dashboard in Glo, where you can quickly see board members, card counts by column and activity for each board. 

Simple board commands can be accomplished from a dashboard including edit, duplicate, or delete. You can also create a new board for your group from the dashboard; after creating the board, you will be immediately directed to your new board. 

Track Project Milestones

The introduction of milestones allows users to create milestones for big projects and associate them with specific cards on a board. Think of these as single-use tags that group a collection of cards by due date. 

To create a milestone, go to your board’s settings and add the milestone name, targeted completion date, and description. You can also come back to board settings to close, edit, or delete the milestone. 

After the milestone is created, it will function much like a label in Glo, and you can assign the milestone to any card within the board. 

Assign a milestone under the Milestonesection, under card details. The milestone will appear on the card as a grey box with the name and a flag icon. 

Unlike labels, only one milestone can be assigned to a card. And while a milestone assigned to a card has a target completion date, the card can maintain its individual due date. 

Use the filter option to quickly view all cards associated with a milestone and card count per column.

Track GitHub Milestones on Synced Boards 

Seamlessly track big projects across platforms by syncing your issue boards with your GitHub repos. Our new feature syncs with GitHub Milestones, so if you close, edit, or delete your milestone in GitKraken or GitHub, you can see the update reflected immediately across both systems. 

GitKraken issue boards continue to add more features to improve the project management process for software developers. Dashboards and milestones makes it easier to track tasks, issues, and timelines across teams and projects. And our numerous integrations with GitHub and Slack allow you to connect your preferred tools to reduce context switching.

In 2019, Axosoft hosted two #AXOSMASH video game tournaments for the local Phoenix tech community featuring Super Smash Bros. Ultimate. All proceeds from the tournaments, one held in March and one in September, went to benefit our #ItWasNeverADress nonprofit which funds scholarships for women to enter the tech industry. 

The Story Begins… 

This was the ending to a note our Krakenites received from a fellow software development team at American Express. Our dev team plays Super Smash Bros. every day during lunch. They love it.

So we thought hmmmm 🤔Our developers play Smash, the American Express developers play Smash…is this a trend?! Sure enough, it is. 

We first took the Amex team up on their challenge, and then got straight to work sourcing more development teams from around the Phoenix Valley who would make worthy foes. 

A Tournament of Champions 

Between the two #AXOSMASH tournaments, we hosted a total of 20 teams and 87 players from the Valley’s top tech companies. 

Worthy competitors from Amazon, American Express, Nextiva, McKesson, GitKraken, Charles Schwab, Allstate, DriveTime, General Dynamics, Pagely, and more tried their hand in a double-elimination, 1v1 tournament for a chance to earn fame and glory. 

Trust us …things got intense. Don’t be fooled by the fist bump. 

Of course there were prizes! And funny enough…we had the exact same final three, in the same order, in both tournaments. In total, the first place winner, from OSIsoft, took home $300; 2nd place, from Pagely, took home $150; and 3rd place, from GitKraken, took home $75 in cash.

All Proceeds Support Women in Tech 

All proceeds raised from #AXOSMASH went to Axosoft’s #ItWasNeverADress nonprofit which provides tech scholarships for women. In August 2019, we graduated our first three scholarship recipients from computer science bootcamps and hope to fund many more scholarships in the years to come. 

#AXOSMASH In the News 

The local community was a buzz about #AXOSMASH; we even had a few news stations come out and learn more about what we had up our sleeves. 🤩

Checkout more photos from the March 2019 #AXOSMASH and September 2019 #AXOSMASH on the Axosoft Facebook page. 

The GitKraken Git Client was one of the first software products of its kind to hit the market in August 2014, built by Axosoft developers who were on a mission to find a Git GUI that didn’t suck. One that could quickly show who was doing what, to which file, on any project; one that could help expedite individual workflows and improve team collaboration; one that visually blew the minds of everyone who interacted with it. 🤯

We let our developers loose to build the greatest Git GUI the digital world had ever seen. Despite the entrance of new competition in years since GitKraken’s initial release, our speed, performance, and functionality (not to mention our mascot, Keif), continue to satisfy and delight our growing user base of millions of developers around the world. 

But don’t take our word for it. We’re so confident in our product that we’re willing to lay it all out on the table and tell you how we compare to the competition. In this article, we will be focusing on our how the GitKraken Git GUI stacks up to SmartGit. 

Detecting Merge Conflicts  

✅GitKraken | ❌SmartGit

Unlike GitKraken, SmartGit does not detect merge conflicts. Not only does GitKraken clearly notify you of a conflict, our merge conflict tool is by far one of our most popular features. 

Merge conflicts in Git can be notoriously intimidating, but they’re a breeze with GitKraken. Imagine you’re working with two branches that propose conflicting changes to the same line in the same file. Upon attempting to perform a merge, GitKraken will detect the conflict and alert you that it needs your help. 

GitKraken then shows you a list of the conflicted files. Clicking on a file will open the merge tool, which displays the conflicting changes side-by-side along with an output view at the bottom.

Each conflict section has a checkbox and, if checked, will be added to the Output section at the bottom. You can then use your mouse to select other lines to add to the output by clicking the + icon. Use the up and down arrows to navigate between conflicts. 

Once you have resolved the conflicted files, you may proceed with the merge and return to your regularly scheduled workflow.  

We recently made our merge conflict tool even better with perf improvements to scrolling, output, line editing, and conflict line selection. Our merge tool now uses the Monaco editor, allowing users to search independently within the three conflict windows. We’ve also added the auto-complete capability to the output editor. 

Let’s compare this experience to resolving conflicts in SmartGit. You have to go through all conflicted files line by line and modify them as needed. No help detecting the conflict, and no main UI for seeing the conflicts side by side to compare proposed changes. 

Fast Global Search 

✅GitKraken | ❌SmartGit

SmartGit lacks fast global search. We know this is an important feature for developers using Git; there have even been requests from SmartGit users to implement something like the GitKraken Fuzzy Finder in their software. 

In GitKraken, our Fuzzy Finder is a great way to quickly access our application’s actions and features. You can open repositories, search commits, view file history, open settings, and much more. 

Open the Fuzzy Finder with the keyboard shortcut Cmd/Ctrl + P and start typing to accomplish a variety of actions. You can view the list of supported commands in our Fuzzy Finder documentation. 

Our Fuzzy Finder is yet another example of how GitKraken helps expedite your productivity as a developer. 

Pricing 

Not only is GitKraken’s pricing model more straightforward, our product is less expensive than SmartGit. SmartGit licenses start at $59 a year for individual licenses, compared to GitKraken at $29 year. Side note: GitKraken is FREE if you’re working with public repos. Shout out to our open source peeps! 

A $49 investment with GitKraken gets users a Pro license for one year, boasting all the bells and whistles our Git client offers. SmartGit’s cheapest offering, at $59 a year, comes without numerous features, including their distributed review add-ons for fast code reviewing. To get all of SmartGit’s core features, you’re looking at just under $90 a year for an individual license.

Undo Button 

✅GitKraken | ❌SmartGit

SmartGit has no undo button. Our Undo button is straight magic. ✨ Keif wishes he had a Kraken Coin for every time a user has told us how the Undo button saved their butt after performing a merge incorrectly. 

Let’s say you’re working in the command line, hit the enter key, and suddenly, you experience a panic surge as you realize you’ve just made a grave mistake. Cue cold sweats and shortness of breath. 

Now let’s play that same situation back using GitKraken. Make a mistake? Simply click the Undo button in the top toolbar of your UI and get back to your workflow. Go ahead, embrace your inner Dr. Strange.

The Undo button allows users to undo the following actions in GitKraken: 

• Checkout
• Commit
• Discard 
• Delete branch
• Remove remote
• Reset branch to a commit 

Furthermore, GitKraken also has a Redo button if you ever get click-happy and undo something by mistake. We got you.

Pull Request Templates 

✅GitKraken | ❌SmartGit

SmartGit does not support pull request templates, an element of team coding that has become an accepted industry best practice. GitKraken supports PR templates from GitHub, GitLab, and Azure DevOps. 

As a developer, you have a responsibility to not only fix issues and implement new features, but to also clearly communicate your work to product owners, team members, or other collaborators who are reviewing the code. 

Through our PR integration, GitKraken gives users the ability to provide concise descriptions of their submitted code through pre-formatted templates, ensuring consistency regardless of who on your team is submitting the request. 

Better yet, GitKraken issue boards recently got a new feature allowing users to link Glo cards with GitHub pull requests! Users can track the status of a PR and automate moving a card into a new column on their Glo board based on whether the pull request has been opened, closed, or merged. 

Furthermore, you can associate a Glo card when creating a pull request in GitKraken by searching for the card in the PR template form. The card link will display in your pull request description in GitHub as the title of the card. 

Azure DevOps Integration

✅GitKraken | ❌SmartGit

SmartGit doesn’t integrate with Azure DevOps, unlike GitKraken, which integrates with  GitHub, Bitbucket, GitLab, and Azure DevOps hosted and self-hosted services. 

GitKraken users can quickly connect to Azure DevOps through our app. After the authentication process, users can expect the following benefits: 

• Close repos from your Azure DevOps repository list
• Add remotes for your Azure DevOps repos
• Create and view pull requests
• Automatically generate an SSH key pair and copy it to Azure DevOps
• And more…

The Best Cross-Platform Git GUI 

At the end of the day, the tools you choose to use depend on your personal preferences and workflows, but the masses have spoken. GitKraken is the most popular Git GUI used across Windows, Mac, and Linux. 

Hear it from our customers, listen to why students love learning with GitKraken, or read our reviews on Slant, G2Crowd, and Product Hunt. 

Are you ready to release the Kraken? 

Are you convinced yet? Join millions of other software developers and engineers worldwide in maximizing the productivity of your workflow with GitKraken, the fastest and highest-functioning GUI on the market. 

Before diving into Git, it’s important to understand the concept of version control at a high level. While not all software developers utilize version control, nor is software development the only industry that does, it is becoming more mainstream every year. And you can bet you will be confronted with version control as a developer if you ever collaborate with others on a workplace team or on open source projects. 

Version control is a system for tracking changes to files and sets of files over time with the intention of recalling specific versions for review. You can also revert back to a previous version of a file when needed. It can almost feel like going back in time. 

Furthermore, using a Version Control System (VCS) allows you to see who made what changes to which file at what time. This makes it extremely valuable when working on development teams or collaborating on projects with fellow students. It adds valuable transparency that affords accountability and better organization.  

There are multiple kinds of VCSs—local, centralized, and distributed—but for the purposes of this article, we will be focusing on Git, a Distributed Version Control System (DVCS). 

What is Git? 

Originally developed by Linus Torvalds, the creator of the Linux kernel, and released in 2005, Git has become the most widely used VCS in the world today.

With Git, a developer’s working code is an exact cloned repository containing a full history of changes, rather than having just one place for the version history of a project, as is the case for centralized systems like Subversion. 

Since its arrival in 2005, Git has continued to improve developers’ workflows worldwide, hence its ever-increasing popularity. And thankfully, Git-obsessed developers, like yours truly at GitKraken, have been working hard in recent years to bring you software tools to enhance your Git experience. 

Best Developer Tools for Git 

GitHub 

Before getting started with Git, you will need to decide where to host your repositories. Popular hosting services include the hosted and self-hosted versions of GitHub, GitLab, Azure DevOps, and Bitbucket, all of which are supported by the GitKraken Git GUI. 

You may be wondering why. As industry expert Jenny Bryan explains in her white paper: 

Like a safe storage place for your code. Even if you’re working on a personal project all by yourself, it’s still a good idea to backup your code by pushing your work to a remote location. 

Regardless of which hosting service you or your team choose to use for day-to-day work, having a GitHub account and engaging on the platform is encouraged for any developer using Git because of the expanse of open source code available. Basically, if you’re using Git, you’re going to use GitHub at some point. 

And consider the exposure to a global developer community. If someone needs to review your work, they can easily access it directly through GitHub. Likewise, say you want to evaluate how a respected influencer works through their public projects; this information is available on their GitHub profile for any user to see. Or, let’s say you want to contribute to an open source project on GitHub; download a working copy, submit a pull request, and start collaborating. It’s like a social media platform for software development. 

*It’s important to note that GitHub also support private repositories, and related code is not publicly accessible.* 

Git GUI

What is a Git GUI you might ask? It’s a graphical user interface that makes the experience of using Git more streamlined than performing actions on the command line. 

Specifically, the visual experience of using a Git GUI is much more appealing and intuitive than the CLI. Below, you can find a visual comparison of a file’s working project history shown in both the command line and the GitKraken Git GUI.

In GitKraken, you can clearly see exactly which commits were made by whom on which branch. You can even see context on each commit clearly, and individual gravatars show who is responsible for what changes; all information you can obtain in a quick snapshot without dissecting lines of code. 

Git GUIs are essentially performing Git actions on your behalf, and some are more robust than others. The GitKraken Git GUI offers drag-and-drop functionality (for devs who aren’t too proud to use a mouse ). You also get significant context in the UI, including a commit panel on the right and a left panel showing all of your project’s remotes, pull requests, submodules, and more. 

The GitKraken Git GUI is loved my millions of devs across the world for many reasons, but Git aficionados are especially fond of the the GitKraken Diff Tool, which shows users exactly what modifications have been made to a file over time.

Another fan favorite, the GitKraken Merge Tool allows users to take commits on two difference branches and combine them. But, let’s say the two commits have conflicting changes to the same file. Fear not Git apprentice! GitKraken will alert you of the conflict and direct you on how best to resolve it.

GitKraken is cross-platform, meaning it can be used with Git on Windows, Mac, and Linux. It also has built-in integrations with GitHub, GitLab, Azure DevOps, and Bitbucket for easier repository management and a more streamlined workflow.

Issue Tracking Board

As with any project, organization and task tracking can come in handy when using Git. And while Git is literally helping you organize your file history and code changes, you will still want a tool for tracking specific project tasks at a high-level to ensure you’re on schedule for your next release deadline. 

GitKraken issue boards is the only kanban software of its kind, built exclusively for developers and development teams. Integrations with GitHub Actions, Pull Requests, and Milestones make it the perfect tool for devs using Git and GitHub. 

Through GitKraken’s integration with GitHub Actions, you can automate the manipulation of cards on your boards. For example, you can trigger a card to move into your Deployed column after a pull request is merged in GitHub. Pretty cool, right? 

Similarly, you can set up an integration to connect GitKraken boards to GitHub Pull Requests. You can map your automation process to move cards to specific columns based on the PR status in GitHub, whether it’s opened, closed & merged, closed, or merged. 

Finally, sync GitHub Milestones with GitKraken to track your tasks against your project milestone deadlines. When you close, edit, or delete your milestone in GitKraken or GitHub, you can see the update reflected immediately across both systems. 

Become a Git Boss

Git can be overwhelming when you’re just getting started, and these tools will help you become more confident in your daily workflow as a developer.

Become a true #GitBoss and level up your dev game with these recommended Git tools.