Say hello to the new Axosoft Slack bot! This Slack bot will allow you to access information about your Axosoft items without ever leaving Slack.

What can Axosoft Slack bot do?

You can type in get my upcoming items and Axosoft Slack bot will provide you with a list of those items.

You can also access your item details by typing in axo and then the item number (I.E. axo19).

Here’s a handy list of all the commands you can use to interact with Axosoft Slack bot:

Show me more!

For more details about Axosoft’s new Slack integration, watch this clip from our v17 webinar.

How do I set it up?

If you’re ready to setup Axosoft Slack bot, follow these instructions:

1. Add the bot to your Slack team:

Click on the button below to add the Slack bot to your account. In the popup window, you can authorize the @axosoft bot, and it will be added as a user in your Slack account. This only needs to be done once for your team.

2. Enter your Axosoft URL:

The Axosoft Slack bot is a user in your Slack account that can be direct messaged or mentioned in any channel. After adding the bot, the first time you try to get data (like @axosoft get my open items or other commands listed above), it’ll ask you to enter the URL for your Axosoft account and log in. Enter the full URL, and we’ll save it for later to connect to your database.

That’s it! For more information, check out our documentation.

To see the other new features and updates that were made in v17, check out our blog article.

This has been a big year for our company with GitKraken taking on the Git world full-force! We know we wouldn’t be where we are today without the support of the developer community. Thanks for not being afraid to tell us what you think, what you like, and what you don’t like. Our mission is to build world-class developer tools, and we need your feedback to do that.

As we head into 2017, we wanted to know what dev tools our community loves to use. In order to find out, we emailed our GitKraken newsletter subscribers and asked them to tweet their top 5 dev tools using #MustHaveDevTools. We were blown away with how many responses we got (over 550 as I write this, and they’re still coming)!

So, without further ado, here are the top 20 must have dev tools. These results are based on the 20 tools that received the highest number of mentions (1 being the most and 20 being the least).

Top 20 Dev Tools

1. GitKraken: The downright luxurious Git GUI client for Windows, Mac, and Linux.
2. Atom: A hackable text editor for the 21st Century.
3. VS Code: A free, lightweight tool for editing and debugging web apps.
4. Git: A free and open source distributed version control system.
5. GitHub: A web-based Git repository hosting service.
6. Visual Studio: Developer tools and services for any platform with any language.
7. Sublime Text: A sophisticated text editor for code, markup, and prose.
8. Chrome DevTools: A set of web authoring and debugging tools built into Google Chrome.
9. Docker: An open platform for developers and system administrators to build, ship, and run distributed applications.
10. GitLab: Git repository management, code reviews, issue tracking, activity feeds, and wikis.
11. IntelliJ IDEA: A Java IDE.
12. PhpStorm: A commercial, cross-platform IDE for PHP.
13. Postman: A powerful GUI platform to make your API development faster & easier.
14. ReSharper: A Visual Studio extension for .NET developers.
15. Slack: Real-time messaging, archiving, and search for modern teams.
16. PyCharm: An IDE used specifically for Python.
17. Android Studio: The official IDE for Android platform development.
18. Notepad++: A free source code editor which supports several programming languages running under the MS Windows environment.
19. Xcode: an IDE for macOS/and iOS development.
20. Stack Overflow: The largest online community for programmers to learn, share their knowledge, and advance their careers.

Honorable Mentions

1. Coffee
2. Beer

If you know our company well, you might be wondering, “what about your Scrum project management software, Axosoft?!” Well, the community we polled is mostly software developers who are more focused on coding tools, but, just maybe, they haven’t seen Axosoft’s fresh new look!

While our developers have spent a lot of time working on GitKraken, they’ve also spent the better portion of this year working on Axosoft v17 Beta, which was just released, and contains significant UI and UX improvements. So who knows, maybe both our tools will make this list next year!

Shortcodes are great – they save time, reduce coding errors and help to keep things looking consistent. But they’re not always intuitive for everyone and lack the more familiar GUI integration many people prefer. In this guide, we’re going to create a plugin for the TinyMCE editor, inside our WordPress theme. When we’re done, we will have a new button in the editor’s toolbar, which will trigger a modal window. This window will offer the user three text fields, where they can add the author, citation and citation URL in a more simplified fashion. Confirming these properties will convert the selected text into a shortcode for the blockquote, and insert any defined attributes automatically.

File structure

We’ll start with the file structure. As with the previous tutorial, we’re going to write our PHP in the regular functions.php file, although again, I’d recommend having a separate functions folder with dedicated files, and requiring those, for a tidier approach.

We will need to create a js folder (if you don’t already have one), and inside that, create a tiny-mce folder in which we’ll create an img folder and a tiny-mce.js file. So, your theme folder should contain the following:

js
|- tiny-mce
| |- img
| |- tiny-mce.js

Create an icon

You can do this however you want, but you’ll want to end up with a 48px x 48px image file. Our file will be called quote.png.

HINT: There is an excellent project called Font-Awesome-SVG-PNG that has black and white SVG and PNG versions of Font Awesome’s icon sets.

Once you’re done making your icon image, place it in the img folder.

The JavaScript

Now, let’s work on the JavaScript! Start with the opening functions. We’ll use the create method of the tinymce object to create the plugin:

(function(){
  tinymce.create('tinymce.plugins.MyPluginName', {
  
  });
  tinymce.PluginManager.add( 'mytinymceplugin', tinymce.plugins.MyPluginName );
})();

Currently, we have an empty function for our plugin. We’ll go ahead and add that plugin beneath the function. Rename the placeholder names to suit your theme.

The second parameter of the create method, is where the meat of our plugin exists. It’s an object, and we’ll put in two methods: the init method, which contains the meat’s meat, and the getInfo method, which provides some information about our plugin:

tinymce.create('tinymce.plugins.MyPluginName', {
  init: function(ed, url){
  
  },
  getInfo: function() {
    return {
      longname: 'My Custom Buttons',
      author: 'Plugin Author',
      authorurl: 'https://www.axosoft.com',
      version: "1.0"
    };
  }
});

The getInfo method calls a function that returns the values above, which should be self-explanatory. Let’s work on the init method next.

The function called by init contains two parameters we’ve defined above as ed and url. ed is the editor object, and url is the URL relative to the folder in which the current .js file resides.

Inside the function, we will call a couple of methods against the ed object, addButton and addCommand. addButton, err, adds the button, and addCommand binds the functionality to that button exclusively.

We’ll add the unique name of our button as the first parameter of addButton, and then the object that forms the second parameter will contain our image, the title of the button (shown on mouseover), and the icon image (using url):

ed.addButton('myblockquotebtn', {
  title: 'My Blockquote',
  cmd: 'myBlockquoteBtnCmd',
  image: url + '/img/quote.png'
});

Next, we can set up the command with the addCommand method. This is broken down as follows:

1. The first parameter of the method is the cmd value you defined in addButton
2. The second parameter is a function made up of five basic parts:
   1. Retrieval of the selected text from the editor
   2. Opening the window using ed.WindowManager and setting:
      1. the title
      2. the window’s fields
      3. the window’s buttons and how they function
      4. what happens when information is submitted from the window

Let’s go through each part.

We grab the selected text from the editor and define its format as HTML so we retain any HTML code.

ed.addCommand('myBlockquoteBtnCmd', function(){
  var selectedText = ed.selection.getContent({format: 'html'});
});

The remaining four steps are all contained as properties in an object defined in the windowManager.open method. title is a string, body and buttons are arrays of objects, and onsubmit is a function.

body defines the fields we’ll have in our window:

ed.addCommand('myBlockquoteBtnCmd', function(){
  var selectedText = ed.selection.getContent({format: 'html'});
  var win = ed.windowManager.open({
    title: 'Blockquote Properties',
    body: [
      {
        type: 'textbox',
        name: 'author',
        label: 'Quote Author',
        minWidth: 500,
        value: ''
      },
      {
        type: 'textbox',
        name: 'cite',
        label: 'Quote Citation',
        minWidth: 500,
        value: ''
      },
      {
        type: 'textbox',
        name: 'link',
        label: 'Citation URL',
        minWidth: 500,
        value: ''
      }
    ]
  });
});

Comprehensive documentation on TinyMCE’s available field types is hard to find; I found that this Stack Overflow question and answers contained the most useful breakdown of available options. The above code should be pretty easy to interpret. name should be unique for each button, so its value can be referenced later. value ought to be empty unless you want to define some default text to populate the field.

Next up are buttons:

buttons: [
  {
    text: "Ok",
    subtype: "primary",
    onclick: function() {
      win.submit();
    }
  },
  {
    text: "Skip",
    onclick: function() {
      win.close();
      var returnText = '
' + selectedText + '
';
      ed.execCommand('mceInsertContent', 0, returnText);
    }
  },
  {
    text: "Cancel",
    onclick: function() {
      win.close();
    }
  }
]

We have three buttons:

1. Ok: This will trigger the win.submit() method
2. Skip: Closes the window and returns the selected text as-is, but contained within the blockquote shortcode minus any parameters
3. Cancel: Aborts the whole blockquote process, closing the window and taking no further action.

Finally, the onsubmit method:

onsubmit: function(e){
  var params = [];
  if( e.data.author.length > 0 ) {
    params.push('author="' + e.data.author + '"');
  }
  if( e.data.cite.length > 0 ) {
    params.push('cite="' + e.data.cite + '"');
  }
  if( e.data.link.length > 0 ) {
    params.push('link="' + e.data.link + '"');
  }
  if( params.length > 0 ) {
    paramsString = ' ' + params.join(' ');
  }
  var returnText = '
' + selectedText + '
';
  ed.execCommand('mceInsertContent', 0, returnText);
}

We pass e as the object containing all the info from the submission. This includes e.data, an object containing all the button data. Next, we simply create a params array, push relevant values to that array (if they’re not empty), and then make it a string, joined by a space, to add to our shortcode as attributes. Then, we insert the new content with paramsString in a functionally similar way to how we did on Skip.

Now, we can bring the entire script together:

(function(){
  tinymce.create('tinymce.plugins.MyPluginName', {
    init: function(ed, url){
      ed.addButton('myblockquotebtn', {
        title: 'My Blockquote',
        cmd: 'myBlockquoteBtnCmd',
        image: url + '/img/quote.png'
      });
      ed.addCommand('myBlockquoteBtnCmd', function(){
        var selectedText = ed.selection.getContent({format: 'html'});
        var win = ed.windowManager.open({
          title: 'Blockquote Properties',
          body: [
            {
              type: 'textbox',
              name: 'author',
              label: 'Quote Author',
              minWidth: 500,
              value: ''
            },
            {
              type: 'textbox',
              name: 'cite',
              label: 'Quote Citation',
              minWidth: 500,
              value : ''
            },
            {
              type: 'textbox',
              name: 'link',
              label: 'Citation URL',
              minWidth: 500,
              value: ''
            }
          ],
          buttons: [
            {
              text: "Ok",
              subtype: "primary",
              onclick: function() {
                win.submit();
              }
            },
            {
              text: "Skip",
              onclick: function() {
                win.close();
                var returnText = '
' + selectedText + '
';
                ed.execCommand('mceInsertContent', 0, returnText);
              }
            },
            {
              text: "Cancel",
              onclick: function() {
                win.close();
              }
            }
          ],
          onsubmit: function(e){
            var params = [];
            if( e.data.author.length > 0 ) {
              params.push('author="' + e.data.author + '"');
            }
            if( e.data.cite.length > 0 ) {
              params.push('cite="' + e.data.cite + '"');
            }
            if( e.data.link.length > 0 ) {
              params.push('link="' + e.data.link + '"');
            }
            if( params.length > 0 ) {
              paramsString = ' ' + params.join(' ');
            }
            var returnText = '
' + selectedText + '
';
            ed.execCommand('mceInsertContent', 0, returnText);
          }
        });
      });
    },
    getInfo: function() {
      return {
        longname : 'My Custom Buttons',
        author : 'Plugin Author',
        authorurl : 'https://www.axosoft.com',
        version : "1.0"
      };
    }
  });
  tinymce.PluginManager.add( 'mytinymceplugin', tinymce.plugins.MyPluginName );
})();

The PHP

Thankfully, the PHP is not as involved as the JavaScript. Open up your functions.php file, and we’ll start with two functions to add and register our custom buttons:

function tiny_mce_add_buttons( $plugins ) {
  $plugins['mytinymceplugin'] = get_template_directory_uri() . '/js/tiny-mce/tiny-mce.js';
  return $plugins;
}

function tiny_mce_register_buttons( $buttons ) {
  $newBtns = array(
    'myblockquotebtn'
  );
  $buttons = array_merge( $buttons, $newBtns );
  return $buttons;
}

We add the name we defined in the tinymce.PluginManager.add method in our .js file as a new element in the $plugins array we pass into the tiny_mce_add_buttons function. Then, we point the value to the location of our custom JavaScript file and return the revised array.

Next, register the buttons in a separate function, bringing in the current buttons array, defining our new buttons in a separate array, and finally returning a merged array.

Almost done! Now we just need to call these functions with the appropriate hooks. We create one final function to add these two functions as filters, and then we call this final function as an init action.

add_action( 'init', 'tiny_mce_new_buttons' );

function tiny_mce_new_buttons() {
  add_filter( 'mce_external_plugins', 'tiny_mce_add_buttons' );
  add_filter( 'mce_buttons', 'tiny_mce_register_buttons' );
}

All done! Upload your revised theme files and test out your post editor. You should now be able to highlight your text, hit your new button and customize how your blockquote is made. Here’s how it should look:

Axosoft is dedicated to helping the development community advance by providing quality tools for developers, amongst other initiatives. We know that in order for our community to grow, we need to ensure the next generation of developers like you have the support and tools you need to advance your skills.

That’s why we provide Axosoft, our Scrum project management software, and GitKraken, our cross-platform Git GUI client, free for students!

So, let’s talk about why students love using Axosoft, and how you can get a free Axosoft student account!

Why do students use Axosoft?

Student developers are almost always required to do a capstone project, research project or some sort of group project. Because students oftentimes choose to take online classes, or have to do work remotely (meaning, at home, at the library, or anywhere outside of your classroom), collaboration software is essential to getting these projects completed successfully.

Students need to be able to communicate and sync up on projects regardless of location. This is where hosted Scrum project management software comes in handy!

Axosoft empowers students to share team goals, assign tasks and keep team members accountable for their work.

Why learn Scrum?

Many schools like the University of Advancing Technology (UAT) use the Scrum framework and agile methodologies to teach their students best practices for software development. Scrum and agile have become increasingly popular amongst tech companies, so student developers with an understanding of these concepts have a huge advantage upon entering the workforce.

We’ve created Learn Scrum in Under 10 Minutes, a video which has now been viewed over 1.5 million times (making it the most popular Scrum learning video). It’s used by many Computer Science professors across the world to teach students Scrum. Moreover, our site is dedicated to helping developers learn Scrum in 6 steps.

Professors at UAT and other universities see great success in teaching students Scrum while also having them use Axosoft.

How do students use Axosoft?

In general, students find it easy to follow our tutorials and Scrum learning resources to quickly get started working on their projects in Axosoft.

Students at UAT Game Studios are required to submit screenshots of their Axosoft Release Planners and team burndown charts. This helps students and professors determine each team’s velocity of game production.

It’s easy to know if your project can be completed on time with Axosoft’s custom dashboards, which include burndown charts, velocity calculations and projected ship date widgets.

The kanban board in Axosoft allows students to visualize tasks easily, and know who’s working on what. Plus, you can simply drag and drop items through the workflow steps.

There are many more features that make Axosoft a great, free Scrum project management tool for student developers, such as release planning, task prioritization, team capacity calculations and work logs!

How do I get a free student account?

It’s easy to get started with a free Axosoft account for one year! Simply click below to create your free account.

Create Free Account

We’re always looking for ways to help users quickly and easily take advantage of all the features that Axosoft has to offer! If you follow us on Twitter, you probably already know that we share an #AxoTip each week to help you learn something new in Axosoft.

We’ve put together this roundup so you can find our 10 latest tips in one place. (Check out our previous roundup for more tips.) These GIFs also show off the fresh, new look of Axosoft v17 beta. Enjoy!

Axosoft Tips

1. Use tabs to organize different types of items. Right click on any tab to rename it. 
2. Need to rank items? Click the down arrow ⬇️  next to List View and select Rank View. Then drag and drop to rank items. 
3. Avoid doing a full page refresh by using the soft refresh  button in your toolbar.
4. To save yourself some time, get a list of all keyboard shortcuts by hitting shift + ?
5. Save time ⏰  with these toggle panel keyboard shortcuts:Left panel: Shift+ L,
   Right panel: Shift + R, Bottom panel: Shift + B 
6. So you want to find an item quickly, eh?  If you know the item ID, use the shortcut v + f to quickly search for a work item. 
7. It’s the great escape! Hit the Esc key or your browser back button to exit out of any item or popup window in Axosoft. 
8. Add the History tab to see the history of all your items. Admins get the superpower to see the history of all users’ items. 
9. Say cheeeeeese!  Use Gravatar to easily update your user avatar in Axosoft.
10. In the Organize panel, quickly see what items each team member has been assigned by filtering the Users and Teams pane.

Software developers, students, and a few sea creatures have spoken. In our recent survey, GitKraken was voted top dev tool of 2016. If you use Git for version control, you should definitely check out our Git GUI!

You might, however, be on the fence; maybe you’re Git-curious, but not sure whether to ‘commit’ (sorry) to a GUI. After all, there are several out there. Which one should you choose? If you’re still deciding which Git client is best for you, perhaps this helpful flowchart will point you in the right direction. Take a look to see how SourceTree and GitKraken compare!

Now, why did so many of the developers we surveyed say that GitKraken is a vital tool in their development workflow? Here are a few ways that GitKraken outshines SourceTree:

1. SourceTree doesn’t support Linux (⅕ of the developer community). GitKraken, on the other hand, will dutifully manage your Git projects without bias toward your operating system. Windows, Mac and Linux users rejoice!
2. GitKraken’s interface is simple, intuitive and customizable with light and dark themes. If you’re going to use a GUI, it should look good! You’re worth it! Treat yourself!
3. One-click undo! What Git client can do that? Certainly not SourceTree (or even the CLI for that matter).
4. Resolve merge conflicts with more control over which bits of code to include by using GitKraken’s built-in merge tool. With SourceTree it’s “mine,” “theirs,” or open another application.
5. Use the input methods you’re most comfortable with. Execute actions using drag-and-drop, or stick to the keyboard and switch repos, check out branches, etc. with GitKraken’s Fuzzy Finder and Command Palette. This is something you can also do in SourceTr– oh no, you can’t.
6. The graph in GitKraken is not only a beautiful representation of your work, it is also a highly functional tool for managing your branches and commits. Interact directly with branches and commits when you merge with drag-and-drop, create branches, or revert commits. If you’re collaborating on a project, avatars act as visual markers that let you know who committed work. Icons on branch labels show which remotes and PRs they belong to.
7. GitKraken Pro is one of the apps available through the GitHub Student Developer Pack, meaning students get access to GitKraken Pro’s features (including profile switching and the ability to edit merge conflict outputs in-app) for free.

So, what’re you waiting for? Switch from SourceTree or your current Git GUI to GitKraken Pro, and take advantage of our promo to get 50% off!

Two is so often better than one. Terminator 2, Led Zeppelin II, Aliens, Mad Max 2 (The Road Warrior), Lawnmower Man 2, Troll 2, Fuller House, Sonic the Hedgehog 2, Halo 2, The New Testament (spoiler alert: everyone dies). The list goes on. But that list now includes GitKraken! We’re really, really excited to announce version 2.0, a release so full of improvements that it deserves it’s own number.

So, what’s new? Well, the first thing you might notice is a sleeker look. Both the light and dark themes have undergone some subtle-yet-significant changes. Not only do they look better, they’re visually more consistent and easier on the eye.

However, this version is much more than a splash of paint. We didn’t just let down its hair, take off its glasses and watch it sassily turn down eating lunch with the sorority girls. Nuh-uh.

Performance

With this major release of GitKraken, the focus was on significant performance overhauls. You probably noticed that we didn’t keep to our usual two-week release cycle this time around. That’s because our keyboard mechanics had GitKraken in bits all over the garage floor, carefully attending to every fine detail to get things tuned, and this took time to get it right. There was stress. There were tears. There were losses, including but not exclusive to sleep, hair and blood.

There was, in reality, rigorous QA testing over a long period of time, and no one was willing to release this version to the public until every GitKraken dev agreed that it hit the aggressive performance targets we had set.

For a full breakdown of v2.0’s features and improvements, you can check out our release notes, but here are the main highlights.

Commits are significantly faster. Here’s a comparison between version 1.9.3 and 2.0:

Opening a repo takes much less time. Don’t take our word for it, check out this comparison:

Keyboard to scroll: in previous versions, GitKraken would take a while to catch up with keyboard input when scrolling. Try it now; it’s a silky smooth experience. But we would say that, wouldn’t we? That’s why this comparison proves our point.

Staged files no longer act like they have stage fright. They’re now snappy as can be. Sounds too good to be true? Here’s another side-by-side:

Staging hunks and lines: Who wants to wait for your hunks to get onstage? V2.0 gets those hunks in line drastically faster than before. Does that sound like an ‘alternative fact’? Here’s what you need to prove it’s an actual fact:

Even with all these performance enhancements, we’ve still managed to address some of the most popular feature requests made by our users.

New Features

.gitignore Finally! You can use the staging area to add files or folders to your .gitignore file. Use the contextual menu, and get your repo to be as ignorant as it needs to be.

Need fast access to your repo in the CLI? Now you can go to File > Open Terminal, and GitKraken will open your preferred CLI app and cd right to your repo directory. The first time you use this feature, you’ll be prompted to select your app of choice. After that, GitKraken will use that as the default. Or, you can go to Preferences > General > Default Terminal and change your default whenever you like.

Now, launch GitKraken and marvel at Keif the Kraken in full joy mode. Why is Keif so happy? Keif is so happy because of you. You.

Opening a repo also has a new loading graphic. The old one was a bit boring, wasn’t it? Also, it rotated just a little bit off-center. It was a bit like George Clooney as Batman: something was just off about it. Well, check out sleek Keif! This is a cool-but-serious side to Keif, showing you that this is one Kraken who means business and will open that repo at least 2x faster than before.

So there you have it! New year, new GitKraken; less time waiting for things to happen.

Lights, camera, action! GitKraken v2.0 has arrived! What better way to celebrate than by giving away cash and prizes to our users?! It’s our way of saying thank you for being so awesome and supportive.

So, take a seat in the director’s chair; you could be 1 of 20 lucky winners!

Contest Details

It’s pretty simple, all you have to do to enter the contest is create a YouTube video that shows how you use GitKraken. Then, share the video on Twitter using #GitKrakenV2 and tag @GitKraken.

Click here to tweet! Note: All you’ll need to do is add your video URL.

Need a little more guidance or creative inspiration? Here are a few ideas to get you started:

• Show off your favorite GitKraken features.
• Show how to do something in GitKraken.
• Show how GitKraken saves you time.
• Show how GitKraken compares to the CLI or another Git client.

Video Guidelines:

• Must be 90-seconds or less
• Must be uploaded to YouTube
• Must be shared on Twitter using #GitKrakenV2 and @GitKraken
• Must include some part of the GitKraken UI
• Must be submitted by 11:59pm PST on February 6, 2017

Prizes

Total prizes valued at $8,500! Enter to win 1 of 20 prizes: 

• 10 GitKraken users will win $100 Visa gift card!
• 10 more GitKraken users will win a GitKraken Pro team account for up to 25 users (up to a $750 value per account)!

The Nitty Gritty

All winners will be notified on February 9, 2017. GitKraken accounts cannot be substituted for gift cards or vice versa. If you’re really eyeing the 25-user GitKraken Pro account, gather your team and create multiple videos to better your chances of winning! Only one entry per participant. Winners of the GitKraken Pro team accounts can claim an account for 1-25 users.

Annnnnnnd action! We can’t wait to see what you love about GitKraken. 

At Syncfusion, we’ve been developing controls and frameworks for software developers since 2001. Over time, as our product line has expanded—emerging from our first grid control to more than 800 different controls across a variety of platforms—our release management process has become increasingly complex. Fortunately, Git came along and made everything easier.

Git is an open source distributed version control system that is flexible and easy to use for all kinds of teams, no matter how big or small. To adopt Git in everyday development, a model called GitFlow was introduced by Vincent Driessen to help simplify development and release management. This article assumes that you have some prior knowledge of Git and its basic terminologies. It aims to further describe Vincent Driessen’s branching model and how his GitFlow extension can be useful in a release management workflow for enterprises.

You can also check out this video, which explains how GitFlow works in GitKraken:

Workflow Model

GitFlow utilizes the core feature of Git, which is the power of branches. In this model, a repository has two main branches:

1. Master—This is a highly stable branch that is always production-ready and contains the last release version of source code in production.
2. Develop—Derived from the master branch, the development branch serves as a branch for integrating different features planned for an upcoming release. This branch may or may not be as stable as the master branch. It is where developers collaborate and merge feature branches.

Apart from those two primary branches, there are other branches in the workflow:

1. Feature—This derives from the develop branch and is used to develop features.
2. Release—This also derives from develop branch but is used during releases.
3. Hotfix—This derives from the master branch and is used to fix a bug in the production branch that was identified after a release.

We will discuss these branches in detail along with the GitFlow extension used to simplify the management of these branches. The commands we use for the GitFlow extension are based on the Windows environment, but other platforms have similar commands. You can check out the GitFlow wiki for complete details regarding supported commands.

Installing a GitFlow Extension

The following simplified steps will get you up and running on Windows, although GitHub also hosts installation instructions for different platforms.

1. Download and install Git for Windows. By default, it will install in this directory: C:\Program Files\Git.
2. Next, you need to retrieve three files: exe from the util-linux package, libintl3.dll, and libiconv2.dll from the dependencies packages (libintl and libiconv). (For ease of installation, we gathered and uploaded all these files to http://www.syncfusion.com/downloads/support/directtrac/general/ze/dependencies142480694.zip.)
3. Once you have those three files, copy and paste them to the location where Git is installed in your system (i.e. inside a bin folder at C:\Program Files\Git\bin). 
4. Next, clone or download this repository: https://github.com/nvie/gitflow.
5. When done, navigate to the folder named “contrib” (gitflow-develop\contrib).
6. Open the command prompt in that directory in administration mode and type this command: msysgit-install.cmd "C:\Program Files\Git". 

7. GitFlow will be installed and configured in your system and ready to use. You can test it by typing git flow help in the command prompt.

Setting up GitFlow in your repository

When starting a project, you won’t have any code files. No problem, just create a Git repository with an empty directory. When finished, you can clone your repository in your system. In this example, we are using a sample GitHub repository, but the procedure applies for any Git repository.

1. Clone the branch in your system using the Windows command prompt:

git clone https://github.com/bharatdwarkani/gitflow-example.git

2. Switch to the following directory:

cd gitflow-example

3. Initialize GitFlow in this repository:

git flow init

You will receive a message stating that no branches exist and prompting you to use common branch names. If you don’t want to change the default branch names, press enter to proceed. When finished, you will have a GitFlow extension initialized in your repository.

Master and develop branches

The master and develop branches form the base of any repository in Git. The master branch contains a version of the code that is in production, and the develop branch contains a version that is due to be released in an upcoming version. Execute the following commands in the command prompt to check out the master branch in your system.

git checkout master
git push -u origin master

You will be prompted for username and password; enter them to proceed. Next, you will need to push the develop branch to a remote repository (i.e. from your system to sync with GitHub). Since the develop branch is only on your local machine, it has to be moved to a remote repository by executing the following commands.

git checkout develop
git push origin develop

Now you have a repository containing master and develop branches copied from your local machine. This is required only when you first start a project from scratch; otherwise, you could work with one of the following branches.

Feature branch

The feature branch splits from the develop branch and merges back to the develop branch after a feature is complete. The conventional naming of this branch starts with feature/*. This branch is mostly created and used by developers collaborating with teams. The purpose of the feature branch is to develop small modules of a feature in a project.

You might wonder why developers can’t work directly from the develop branch. Why do they need to branch off to a feature branch? To explain this, consider a scenario where you are developing a feature and management decides to drop that feature, as it is no longer required or there is less feasibility of implementing it.

At that time, if you are working in the develop branch directly, it would create a lot of conflicts and possibly break the existing code. Also, to do this you would need to manually delete or comment out code.

Instead, if you branched off a separate feature branch, you could silently discard and delete that branch without affecting the develop branch. Not only does this help develop features, which require the trial-and-error technique, but by using a separate branch you also get an extra level of stability in the develop branch because code from the feature branch undergoes several levels of code reviews and quality assessment before merging into the develop branch.

The lifetime of a feature branch ends once it merges with the develop branch. If multiple developers or teams are working on the same feature, it’s easier for them to collaborate by working on a common feature branch.

The following steps show how a feature branch can be created and published using the GitFlow extension from a Windows command prompt.

1. To clone a repository:

git clone https://github.com/bharatdwarkani/gitflow-example.git
cd gitflow-example
git checkout develop
git flow init

2. To start a feature branch (the name of the feature branch will be the name of the feature; we are using feature1 in this example).

git flow feature start feature1

After execution, the feature1 branch is created, but it exists only on your system and will not be available in the remote GitHub repository. Now you can continue with your development, adding files and modifying the code. When you’re done with the feature, you can commit it to your local system and later push it to the remote repository.

3. Once done, the status of the changes can be checked for newly added or modified files.

git status
git add .
git commit -am "Your message"

4. The following commands publish the feature to the remote repository.

git flow publish feature1
git push

If you check in the remote repository, a branch with the name feature/feature1 will be created.

5. Once a feature is complete and the code has been reviewed, you can complete your work in a branch by issuing the command below. Upon execution, the code will be merged to the development branch automatically and the feature branch will be deleted from the remote repository.

git flow finish feature1

6. If you need to delete a branch, you can execute: git branch -d feature/feature1

git flow feature track feature1 instead of git flow feature start feature1

Apart from this, there is one more branch called bugfix. It has a workflow similar to the feature branch, but it is used to fix a bug.  

Release branch

The release branch derives from the develop branch and merges back into the develop and master branches after completion of a release. By convention, the naming of this branch starts with release/*. This branch is created and used when features are completed and finalized for a versioned release.

Why can’t we directly release from the develop branch? Because the sole purpose of the release branch is to isolate a version of a release that is final but needs some quality assistance and stability from the upcoming version. If we branch off from the release branch, then other developers who are assigned to develop features for an upcoming release and are not involved in the release stability process can continue to development and merge their features into the develop branch without waiting on or affecting the current release process. The release branch helps isolate the development of an upcoming version and the current release.

The release branch’s lifetime ends when a particular version of a project is released. Once this branch merges into the develop and master branches, it can be deleted. And once you have done this, you can tag a master branch with a particular release version—let’s say v1.0—to create a historical milestone.

The following example explains how a release branch can be created and published using the GitFlow extension from the command prompt.

1. Start a release branch.

git checkout develop
git pull
git flow release start release1

2. Commit newly added or modified changes and push to the remote repository.

git add .
git commit -am "Your message"
git flow publish release1
git push

3. Merge changes to the develop branch.

git checkout develop
git merge release/release1

4. After a release, merge changes to the master branch.

git checkout release/release1
git pull
git flow release finish release1

-or-

git flow release finish -m "Your message" "release1"
git checkout master
git push --all origin

Hotfix branch

The hotfix branch is derived from the master branch and merged back after completion to the develop and master branches. By convention, the name of this branch starts with hotfix/*. This branch is created and used after a particular version of product is released to provide critical bug fixes for the production version.

The reason we do this is because one problem you might face when branching off from the develop branch is that some of your developers would have already started work for the upcoming release while you are in the middle of the current release. Your release would contain the next version of features, which are not finalized, but you only need to provide bug fixes for the current version. Instead of branching off from develop branch, you can branch off from the master branch, as that branch contains only the current version of the code in production. This way, branching off from the master branch will not affect your production or development version of the product.

The hotfix branch can be deleted once a critical fix for the current production version is released and merged with the master and development branches. Once you have done this, you can again tag the master branch with an iterative subversion of the release; let’s say v1.1.

This example shows how the hotfix1 branch can be created and published using the GitFlow extension from a command prompt.

1. Start a new hotfix branch and commit changes after modifications.

git checkout develop
git flow hotfix start hotfix1
git status
git add .
git commit -am "Your message"

2. Publish the branch to the remote repository.

3. git flow publish hotfix1
   

   Merge changes to remote repository.

git flow hotfix finish hotfix1

-or-

git flow hotfix finish -m "Your message" "hotfix1"
git status
git checkout master
git push --all origin

Summary

The GitFlow model helps manage and organize a release better by using GitFlow extensions. Thank you, Vincent Driessen, for proposing GitFlow and for providing an extension that helps simplify the management workflow of enterprise-level releases.

Mastering the full functionality of Git takes time, so you’ll probably benefit from books like Git Succinctly and GitHub Succinctly. Both are part of Syncfusion’s Succinctly series of e-books—an acclaimed library of short technology books designed to orient you quickly with new technologies. The series is a great resource for developers, numbering more than 100 titles—all completely free.

If you choose to fully embrace the tenants of GitFlow order, know that you can use them with Axosoft’s GitKraken, a cross-platform Git GUI built to help put Git into human terms.

As an immigrant from Iran, and an American citizen who has lived in the U.S. for more than 33 years, I was disheartened to see President Trump’s executive order to ban certain immigrants from entering the country; especially those who have legally obtained Visas or legally gained permanent residency (although they later reversed this decision).

I believe that America’s greatness comes from its diversity and the power of individual citizens to speak up without fear of persecution. At Axosoft, we embrace diversity. We don’t run from it. We think it’s a fundamental key to success, which is a point I made sure to reiterate in an all employee letter.

Because diversity is foundational to who we are and the culture we’ve created at Axosoft, we knew we had to do something in light of the injustice caused by the President’s executive order. We also knew we couldn’t be the only ones who wanted to fight back.

That’s how we found the American Civil Liberties Union (ACLU), who has already stepped up and is fighting to correct this wrong. After researching more about the ACLU, I learned that they have been defending and preserving the rights and liberties of Americans for nearly 100 years. During this time when our rights are frequently being challenged, I was relieved to find this organization.

So, to show our support, Axosoft will be donating 100% of GitKraken Pro revenues to the ACLU, for the next 3 days (from Wednesday, February 1st, to Friday, February 3rd). Whether you are buying 1 GitKraken Pro license or 100 licenses, the revenues will go directly to the ACLU. You don’t need to do anything special to make this happen.

We will post updates about the progress on our Twitter account in the coming days.

I’ve been with Axosoft for almost two years now, and when I started, GitKraken, the company’s Git GUI, was so new it was still in private beta. Working for the marketing team, primarily on web projects, I needed to work collaboratively and use Git on a daily basis.

I had worked with Git before, but prior to Axosoft, I was a web team of one, meaning I rarely, if ever, had to collaborate with other developers on projects. As such, the extent of my Git knowledge was git status, git commit, and, when feeling saucy:

git commit -a -m 'look at me condensing my actions into one command like a big boy.'

It’s timely that as I write this, I’ve just finished reading a blog article by Avdi Grimm (that references GitKraken, as it happens), in which he makes a point I had never really considered:

Git from the command line, for me, achieves the latter; when using the CLI for Git, I could perform simple commands that made me feel like I was doing something powerful, and maybe I was doing something powerful, but the truth is, I didn’t really know what I was doing. I understood some basics, but I did not, at all, have a sound conceptual grasp of anything outside of those simple commands. Reading up on Git piqued my interest enough to dive further in, but I hit a roadblock, and it started to feel unlearnable.

When I started with Axosoft, we were asked to use GitKraken because a) Axosoft believes in the product and in how strongly it performs (and did even in those early stages of the app’s development); and b) Axosoft wanted devs across the company to put the app through its paces and identify bugs, UX issues, etc.

So, I used GitKraken, and I used Git—truly collaboratively—for the first time. And I started to not only get used to performing tasks quickly, but to actually start making sense of how those tasks were working. Processes were simpler, I was far more productive, and I finally had a visual representation of Git that I felt I could understand.

Merging vs Rebasing

A good example of this, and one of my most satisfying ‘ah-ha!’ moments, is with merging and rebasing. Merging is a pretty straightforward concept to understand: you take a branch, merge into another branch, and that target branch now has the changes of both. What I didn’t understand until I could actually see the process, was that this is facilitated by a merge commit. To understand why this is useful in a collaborative environment, it’s probably best to explain with an example.

In the example setup below, I have a branch and I have master. This setup exemplifies a common situation: I have branched off master, made some changes, but have not finished working on the branch. Meanwhile, master has changed, and those changes are ones I’d find useful to have in my branch.

I have two options: I can merge master into branch-from-master, or I can rebase branch-from-master onto master. The former is entirely non-destructive and leaves a footprint of the process:

However, it’s easy to see how keeping things clean could become difficult when applying this method frequently, while lots of updates are happening around you. In order to avoid this potential conceptual spaghetti of merge commits, a friend recommended I rebase instead.

Whoa! I can actually see the difference, and it makes sense! The changes in master have been slotted into branch-from-master, as if my changes in that branch, and in master, were conducted on my one branch. master still has its commits intact, but it’s as if those commits were conducted on both branches at the same time.

Although this loses the footprint of merging, it keeps everyone’s repos looking clean, with histories that are easier to traverse and interpret. We have literally rewritten the commit history.

This is why, when it’s time to push my branch, it tells me I’m behind the remote. I could see how I had rewritten the history of that branch, so I could understand why a force push to my remote was acceptable under these circumstances. I want to reflect the history revision there, too, so I have to get just a little destructive. However, I can now also understand why there is the Golden Rule of Rebasing.

Using GitKraken has provided me with a visual way to learn some Git fundamentals that have made me more competent and confident with using Git collaboratively. Using a GUI for Git has allowed me to take the step from knowing how and when to do something, to knowing why and what it’s actually doing.

Welcome back! We’ve got 9 more tips to help you navigate GitKraken more efficiently.

If you haven’t been keeping up with this series, check out roundups 1, 2, and 3 for more tips.

GitKraken Tips

1. Switch between dark and light themes in UI Preferences. We gave the light theme some love in v2.0!
2. When viewing file history, select a commit to view its diff then click the commit SHA to jump to that commit in the graph.
3. Use keyboard shortcuts to quickly stage S or unstage U selected files in the right panel.
4. Shortcut cmd/ctrl + \ will minimize or expand the left panel to make room for larger commit graphs.
5. Quickly zoom in/out of GitKraken with cmd/ctrl + +/-. Reset to 100% with cmd/ctrl + 0.
6. Remotes can be fetched individually from the left panel – no need to fetch them all!
7. Check out a branch 4 ways: 1. double click in the left panel 2. in the graph 3. in the toolbar dropdown 4. in the command palette cmd/ctrl + shift + p.
8. Organize branches into folders in the left panel by naming them with a slash between the folder and branch name.
9. With the left panel collapsed, switch repos or branches quickly from the toolbar, the fuzzy finder cmd/ctrl + p or the command palette cmd/ctrl + shift + p
   

I remember when 3D printers were first becoming accessible to everyday makers. One of the new printers touted its ability to replicate itself by printing parts that could make another 3D printer which could print parts for another 3D printer, and so on.

This recursive concept was really interesting, and something I thought about when we were asked this question in one of our recent GitKraken community Slack AMAs:

“Do you manage GK source code completely from GK? If so, how long did it take to be self-sufficient?”

Just like those self-replicating 3D printers, we do in fact use GitKraken to make GitKraken and have been doing so since around version 0.0.3, when it was just a tiny baby Kraken. Using only GitKraken, even in its infant state, was an important exercise that helped ensure we were including features that developers actually needed. It helped us to constantly improve the user experience with each release—because a “powerful” tool that is awful to use isn’t much good to anyone.

If you’ve ever wondered how developers use their own tools that make those same tools, allow me to give you a bit of insight into our process, and show you how GitKraken is vital to its own creation. In this existential journey, you’ll learn how GitKraken devs use GitKraken to make GitKraken.

Imagine you are new to the GitKraken team and eager to start contributing to development. You have a GitHub account right? You do. Everybody has a GitHub account (how do you think grandma submits pull requests to the Linux repo?). So, we would give you access to the GitKraken repository on GitHub (lucky you!) where you would fork your own copy of the GitKraken source code. This is important because it gives you your own safe sandbox to play in without breaking the production version of GitKraken.

Equipped with a safe repo with which to experiment, you’d download and install your own copy of GitKraken, skipping the task of installing Git altogether if you so choose. Then, since you’re working on a GitHub hosted repo, you’ll want to take advantage of GitKraken’s powerful GitHub integration by signing in with your GitHub account. This allows GitKraken and GitHub to talk with one another in a seamless way.

You’ll get a glimpse of the power when you go to clone the GitKraken repo. Instead of going back to GitHub to get a clone URL, just pop into the GitHub tab in the Clone menu, and search for the repository you want to clone. Because you’ve connected GitKraken with GitHub, all the repos you have access to will be searchable in GitKraken for easy cloning.

With your repository cloned and opened in GitKraken, you’ll have a local version on your machine and a remote connection (origin) already set up to the main GitKraken repository on GitHub. Remember that fork you made on GitHub? You’re going to add that as a remote, using that slick GitHub integration, to find your repo on GitHub instead of leaving GitKraken.

All GitKraken developers work from their own forks of GitKraken. Adding those as remotes in GitKraken gives us an overview of who is working on what, and makes it easy to check out someone else’s branch to collaborate with them or review their work. We can also hide the remotes we don’t need to see, keeping the graph tidy. This reduces the number of auto fetches that occur to keep everything up-to-date. Hidden remotes can still be fetched manually from the context menu with a right-click.

Having personal forks of GitKraken makes creating pull requests (PRs) on GitHub even easier thanks to drag-and-drop actions in the left panel. Most of our work is merged into development first for review and testing before it is included in a staging build. When a developer has finished working on a branch, that gets pushed to their remote where it can be dragged and dropped onto origin/development to start a PR from GitKraken.

GitKraken’s GitHub integration continues to save time in our workflow by allowing us to open a PR with all of the relevant information pre-filled in a simple form. All we need to do is add a basic title and description then submit it to GitHub. For more detailed editing, the PR can be easily opened in GitHub directly from GitKraken.

After pull requests are created, we assign developers to review them using GitHub’s pull request review system. In GitKraken, we keep track of open PRs in the left panel and can easily open them in GitHub to review.

Upon approval, a mysterious DevOps process occurs that merges that PR into development, which is used for staging builds for QA to check, and eventually a shiny new release is bestowed upon the world for all to enjoy. Pulling back the curtain on that is an article for another day.

Last week, in response to the executive order banning entry of refugees and visa holders from seven countries into the US, Axosoft Founder Hamid Shojaee announced that Axosoft would be donating 100% of GitKraken Pro revenues to the American Civil Liberties Union (ACLU), over the course of 3 days.

We were not alone in taking a stance against what many have been calling the ‘immigration ban’. Multiple prominent executives of tech companies have also shown their support by offering to match donations to the ACLU: Stripe CEO Patrick Collison, Nest founder Tony Fadell, Slack CEO Stewart Butterfield, and Facebook’s head of advertising Andrew Bosworth, just to name a few.

Thanks to tech executives and nearly 1 million people who have made online donations, the ACLU has received over $79 million in new contributions since the election. We’re happy to announce that we’ll be adding another $17,030 to that total!

The ACLU is using these donations to continue its 97-year-long battle for justice, equality, and democracy. The ACLU has even been accepted into the winter batch of companies enrolled in top Silicon Valley startup accelerator Y Combinator. The nonprofit will receive mentorship and guidance on how to best utilize donations to grow the organization and its infrastructure.

It’s that time of year again. Whether this is a time of lavish attention for you, a time of dread and low self-esteem, or merely an opportunity for you to shake your fist at the cynical commodification of love and affection, we can all agree on one thing: It’s Valentine’s Day, sweetie.

And what greater gift could be bestowed on this most romantic of occasions than a new version release of your favorite Git client, GitKraken?

As usual, you can check out our release notes for the detailed breakdown of what’s new, but here’s a quick summary of what you can enjoy from this most salacious of software updates.

Remote Avatars

It’s always good to put a face to a name, and your remotes are no exception. In a major quality-of-life update, GitKraken now displays your cute remote avatars right in the graph. Doesn’t sound like a big deal, lover? Try having a bunch of refs in your graph and quickly distinguishing between them, honey. Prior to v2.1, this was an obstruction to the efficiency of the app.

As of version 2.1, you can quickly and easily see whose remotes are where, with those remotes being visually identifiable at a glance. (Please note that we can’t vouch for the aesthetic quality of your team members’ avatar choices, though. We’re good, but there are some things we just can’t fix, sugar. )

Left Panel Performance Improvements

Here’s a case where you really DO want to rush into things. We’ve taken some time to overhaul the left panel, making it much, much snappier. Try it out yourself! We’re all friends here. Open a large repo and check out that speed difference. Silky!

Additional Compatibility

We’ve taken some major steps to increase your ability to use the app, and while that may not sound very sexy, it’s a big deal to those of you who were, despite your advances, given the cold shoulder by GitKraken. We listened to your requests, and worked hard on implementing better remote compatibility and – yes! – operation behind proxies!

We’ve shown some real love and devotion to Team Foundation Server (TFS) and Visual Studio Team System (VSTS) in this release, now supporting remotes on TFS 2015, TFS 2017, and VSTS that use HTTPS. Now that’s hot.

@GitKraken is there any hope for us using TFS 2017..? https://t.co/nV0c9o3Ax2

— Jarl Ostensen (@jarlostensen) January 17, 2017

‏@jarlostensen, cutie-pie, there’s hope. We just made your dream come true xoxo

We’re aware that some of you lonely hearts enjoy long walks on the beach, a good romance novel with a glass of wine, and working via a non-authenticated proxy. Well, you’re in luck! If you’re on a non-authenticated proxy, you can now use GitKraken! Apologies if you were enjoying the thrill of the chase with those services, sweetheart.

Oh mighty @GitKraken, free us peasants from our miserable enterprise proxy, release the proxy configuration and rule this commit world

— Guillaume M. (@MrGuiMan) November 3, 2016

Oh ‏@MrGuiMan, precious, consider yourselves released from those shackles!

As with every release, we’ve also made some minor improvements and crushed some bugs with our stiletto heels. Check out the release notes for the detailed view on all our flirtatious fixes. Saucy!

Node whatnow?

Node Sentinel File Watcher (NSFW). It’s a file watching module built for Node.js. I built NSFW to overcome an obstacle we were encountering while developing GitKraken, and I released it as an ongoing open-source project. It’s actually entirely safe for work. Ideal for it, even.

NSFW is a native Node module, which means it is developed and written to run natively on an operating system without an interpreter (JavaScript uses an interpreter, whereas a language like C++ compiles to machine code).

NSFW has a file watching implementation for Linux, MacOS, and Windows, which are wrapped and bound for the node runtime to utilize. Thanks to its native implementation, NSFW is able to watch recursive directories on all operating systems in a very performant way.

What problem does NSFW solve?

At this time, Node has pretty poor support for file watching. Every operating system has a different capacity to watch directories. Here’s what some celebs have been saying on Twitter:

Linux can’t perform recursive directory watching. MacOS doesn’t provide the filename when a file was changed.

Add to these the fact that there are numerous unsolved issues for Node’s file watcher and that Node does not have a consistent experience across operating systems.

How does NSFW solve the problem?

NSFW solves the poor file watching experience on Node by utilizing 3 low-level file watching utilities written in C++ and targeted for the Linux, MacOS, and Windows operating systems.

NSFW does most of its work on a separate thread, giving it big performance gains over the built-in Node file system (FS) watcher API. NSFW queues file events on a separate thread and batches file change dispatches into a single callback. That callback can be throttled internally to prevent spamming the JavaScript/C++ bridge.

This means NSFW doesn’t slow down JavaScript applications, even when they’re under the load of large FS operations.

Linux, MacOS and Windows each ship with their own file watching APIs. Since NSFW’s watch utility is targeted specifically at each of those APIs, it means the experience of using the module is consistent across all three OSs. NSFW fills in the gaps for each API so they’re all consistently feature-complete:

• Linux: The Inotify file watching system does not perform recursive directory watching, so NSFW builds and maintains a recursive watch tree for you.
• MacOS: FSEvents is known to produce inconsistent file events (the file event bitmask becomes corrupted if events occur too quickly), so NSFW stats and disambiguates file change events for you.
• Windows: supports all targeted needs out of the box. (RECORD SCRATCH) That’s right, Windows has the best native support. I said it.

Why this was an important problem for the Axosoft dev team to solve

GitKraken is currently the primary consumer of NSFW. A good Git client should not ship with a refresh button because it should automatically know when things change.

NSFW is essential to the smooth, cross-platform experience of GitKraken, as it helps the app respond quickly and accurately to changes in a repository it is viewing. NSFW is a quiet and humble, no-frills background process. It doesn’t make waves. It doesn’t talk through movies, chew loudly or snore, but its transparency is its strength; if you notice it, it’s more than likely because something isn’t working. So cheers to watching files silently and effectively – something made easy by the NSFW module.

Development hurdles

Oh yes.

With no experience in any of the file watching APIs, little experience in the Native Abstractions for Node (NAN) API, and no clear understanding of how to model the interactions Node makes with each file watching utility, the 0.x.x NSFW releases were, umm, troubled.

On Windows, I tried using C++/CLI to use the fancier file watching module provided by the .NET library. While this made it quick to get up and running, it inevitably backfired, because some users were unable to run GitKraken due to missing library dependencies. Sigh.

I also encountered strange errors related to having two distinct garbage collectors running concurrently (one for Node and one for the managed file watcher). When I scrapped the .NET implementation, I achieved much stronger stability for the Windows operating system.

On Linux and MacOS, issues revolved around unfamiliarity with the file watching API and native constructs. The overall unfamiliarity combined with the different strategies each operating system incorporated, ended up turning the entire project into a spaghetti turd. [REDACTED: DEEMED NSFW BY THE AXOSOFT DEPARTMENT OF PROPAGANDA]

Finally, large file change operations slowed down every operating system. At the time, those messages had no throttling behavior. The Node application would get absolutely hammered by file system change notifications and slow to a crawl. We suffered the consequences of that in GitKraken whenever we walked through our bootstrap process, which involves a lot of file manipulation.

After fiddling around with the project through the 0.x.x months (aka The Dark Times), I learned a lot about how each underlying file watcher API works, including their caveats, demands, and broken bits.

After spending a week putting together a complete system diagram, I scrapped the entire 0.x.x project and rebuilt the project to handle the differences of each operating system in a planned way. I also did away with the C++/CLI interface and opted for ReadDirectoryChangesW in Windows.

A couple of lessons learned

1. Predicting a system’s architecture without first dirtying your hands with the core features, means you’ll probably end up throwing away your project, dirtying your hands with the core features, and starting the project over. As a new developer, be prepared to throw away your prototypes.
2. I’m not sure if C++/CLI and Node should ever be a thing. Ever.

Here at Axosoft, we’re passionate about supporting the development community. For 13 years we’ve been helping grow the tech ecosystem in Arizona by opening up our space to Meetup groups, sponsoring and speaking at local events, and partnering with like-minded organizations. When we can, we also travel to speak at conferences and connect with developers across the globe.

However, what we really want is to be able to connect with devs outside of just our local community more consistently. So we thought, what better way to do that than by supporting your local developer Meetup groups with all the best goodies! Here’s what our new GitKraken Meetup Package includes:

GitKraken Meetup Package

• Food and drinks budget of $200
• GitKraken stickers for all attendees
• Several GitKraken shirts for giveaways
• GitKraken Pro promo code for $10 off a 1-user GitKraken Pro annual account, for every attendee
• Our GitKraken Cheat Sheet

Developer Meetup Requirements

We know it won’t be possible for us to send packages to every Meetup (unfortunately), so we’ve put together some basic requirements that your developer group must meet in order to be eligible to receive a package:

• Must be an established Meetup (or group) with a publicly accessible page
• Must be a developer-focused event
• Must have 40+ attendees regularly

We also ask that you help us spread the word about GitKraken by playing our 90-second Intro to GitKraken video during your Meetup and tweeting @GitKraken with a photo of the Meetup and your Meetup hashtag if there is one.

What is Zapier?

Zapier is a powerful automation engine that connects with hundreds of applications. It’s also a developer platform that allows you to create your own integrations if they’re not supported out of the box.

Axosoft has been a part of the Zapier ecosystem for about 2 years! So, it seems appropriate to celebrate our 2nd anniversary with a public display of affection. The 2nd anniversary is traditionally cotton, so in honor of our favorite Zap ever, let’s call it the ‘velour’ anniversary.

What is a Zap?

A Zapier integration is called a Zap. Even at its most basic level, a Zap can function as a simple-yet-powerful middleman between two services, but nonetheless, all of the possibilities can be a little overwhelming. So, I wanted to offer a popular Zap example: integrating your Trello board with your Axosoft account.

Axosoft + Trello Zaps

Axosoft is a great Scrum project management tool for your development team to manage your backlog, but if you have some team members that insist on a different platform like Trello, you’ll need a way to have the two platforms communicate with each other to avoid task management becoming a cumbersome and inefficient process. Zapier allows you to butt your processes up against each other so you can disseminate tasks to devs on those other platforms.

Create Axosoft items from Trello cards

Imagine a distant land where a company is doing contract work, and the funnel of receiving requests consists of generating a statement of work, and then only sending the task to get worked on in Axosoft after payment is processed. All you’d need is a Trello board with a step called ‘Send to Axosoft’. You’d then make a Zap so that any cards dropped into that step would create the item in any Axosoft Project you select, and would be ready for your devs to work on.

Oh, looky here… We have that Zap for you!

Or you can check out the Zap’s page here.

Create Trello cards from Axosoft

Of course, the reverse is also possible! But you want another example, right? Here goes: sometimes our Marketing team has to follow up with some of the changes in the product, in order to update our version history or documentation with new features. Zapping those over to a Trello board might be pretty handy.

You didn’t think we’d have one for you and not the other, did you? Oh ye of little faith, here you go:

And here’s that Zap’s page.

So, when your developers are done, err, developering, you can have items Zap over to a Trello board!

Start Zapping

If you feel inspired to start Zapping away, you can create a free Zapier account and get creative. You can also check out other cool and useful Axosoft integrations through Zapier in our Zapbook.

To see all the source control, live chat, test case management, and other tools that Axosoft integrates with, visit our integrations page.

Here at Axosoft, one of the most-used tools, unsurprisingly, is the humble text editor. No matter what kind of developer you are, you likely have your own setup for the editor you use: theme, keyboard shortcuts, add-ons; everything configured just the way you like it.

At Axosoft, the most popular editor of choice—by far—is Atom: GitHub’s functional, flexible, open-source, cross-platform editor. Out of the box, Atom is a very capable app that doesn’t take long to feel familiar. But its real strength lies in its extensibility and hackability. This is a real boon to developers with their own unique requirements, languages, preferences and habits. Should you need to, you can tweak config files, or create entire plugins to extend Atom’s base functionality.

These days, there are lots of packages available for Atom, and they’re easy to browse and install from within the app. Here’s a roundup of some of the most-used packages around the Axosoft office.

Our 6 Most-Used Atom Packages

1. linter/linter-eslint

https://atom.io/packages/linter
https://atom.io/packages/linter-eslint

The most popular plugin with our devs, is a combination of two plugins for linting code. A linter is a program that assesses code for probable errors and for enforcing a consistent coding style. The base linter, combined with a JavaScript linter installed on top of the base, is the combo of choice with developers at Axosoft. Syntax typos begone!

2. highlight-selected

https://atom.io/packages/highlight-selected

As you may have guessed, the “Highlight Selected” package highlights your selection; in fact, it highlights all instances of that selection in the document. Simple, but effective if you need a quick reference to all visible instances of a string.

3. pigments

https://atom.io/packages/pigments

Pigments is an indispensable package if you’re working with colors and variables. Pigments highlights all color values (hex, rgb, rgba) with the color that value represents. Among other settings, you can choose the “marker type,” opting for, say, a color dot next to the color value rather than highlighting it in that color.

Pigments supports precompilers, too, so you can use Stylus, Less, Sass, or Scss and it’ll highlight functions and variables that represent colors. Need examples? Well, we all know that Chuck Norris’s hex value is #bada55, but here are a few Stylus suggestions for you:

rocky                  = #ba1b0a
ringo-starr            = alpha(#bea71e, 0.5)
whats-that-smell       = #badc0d
whats-that-other-smell = #faece5

4. minimap

https://atom.io/packages/minimap

Minimap offers an at-a-glance graphical preview of the current document’s entire source code. The package’s home page shows the copious configuration options, but even without setting those, Minimap offers a really easy way to work out where you are in your code, and quickly get to where you need to be.

Combine this package with the minimap-highlight-selected package to see all your selections in the map!

5. regex-railroad-diagram

https://atom.io/packages/regex-railroad-diagram

Do regular expressions fill you with the kind of dread otherwise reserved for dental surgery, high school reunions, going to the DMV, or, actually having dental surgery at your local DMV performed by one of your old high school friends? If so, Regex Railroad Diagrams might be the answer to your prayers. This package offers a visual view of your regular expressions so it’s easier to debug their behavior.

6. rulerz

https://atom.io/packages/rulerz

Where did my cursor go? Where am I in this row? I’m frightened! If only there was a little vertical bar that followed my cursor on the screen, subtly giving me a visual reference for where I am!

Ah, there’s a package for that. Rulerz gives you a simple vertical rule to help you know where you are. What’s more, it’s customizable, thanks to Atom’s stylesheet. Here’s a modest example:

atom-text-editor.is-focused::shadow {
    ruler-view.rulerz {
        border: 10px solid #5234d4;
        width: 500px;
        box-shadow: 0px 0px 10px 10px #ff0, 0px 0px 100px 10px #f00;
        background-image: url('http://i.amz.mshcdn.com/AMO_a36WMI0rtWvQfnvIO8M_PZA=/1200x627/2012%2F12%2F04%2Fa9%2Fnyancatstar.aDm.jpg');
        background-size: contain;
    }
}

Gives you:

Ah, that’s better. And you are most welcome.

There are quite a few things that I do every day in GitKraken that make my work easier. When I just worked with my repos using the command line, these tasks were always a hassle. Maybe, sometimes, the hassle is worth it. Imagine you’re Tom Hanks and you bring an old, manual typewriter to a baseball game to keep score. Now, admittedly, that is really cool, but it’s not something I’d want to do all the time, and the idea of typewriter-like permanence in Git operations makes me shudder a shiver of pure fear. So, in honor of Hanx, I thought I’d share 6 reasons why I prefer GitKraken over the hassle of just banging away on the keyboard.

1. User Friendly

The CLI has a steep learning curve because you have to memorize commands and understand what those commands actually do. GitKraken, on the other hand, is a great tool for learning and teaching Git. GitKraken allows you to simply make a few clicks to perform commands and then provides a visual representation of the commands so you can see their effects.

See that big Undo button up top? That means that if you make a mistake, there’s also a good chance you can undo that mistake.

2. Speed

With GitKraken, you can drag and drop to quickly merge, rebase, reset, push, and more. If you need to undo a commit, simply give the Undo button one quick click.

I also love being able to easily see all of my work in progress; I can stage, discard, or stash any changes as I wish, so I don’t accidentally commit small mistakes. It makes me feel fabulous and powerful like I’m on the Bachelorette, and I can see which hunks I want to keep and which can be discarded.

3. Performance

Ok, look, it’s a GUI, and with a GUI there’s always some trade-off between the convenience of the UI and the demands on your CPU. I’ll admit that the CLI will be less taxing on your machine than any GUI out there, but you’re still getting bang for your buck when using a client.

The background processes that often run on a GUI, though they affect your CPU usage, are often also a great convenience to the end user, keeping up-to-date with file changes, for example.

4. Remote Control

If you’re tracking multiple remotes from your team, it can often be difficult to differentiate your local work from changes on other forks. With GitKraken, you can always see the avatar of the user on GitHub or Bitbucket, to know whose branch you’re viewing, or you’ll see a computer icon for your local changes.

Creating and viewing pull requests is something I do all the time, and I really couldn’t do them in the command line. With GitKraken, I can create new PRs, view my existing PRs in the repo, and even add the remotes attached to the PR if I don’t already have it pulled down.

5. Preference

I hate Git Spaghetti.

We’ve all witnessed a commit graph that is a mess of merges and branches that people forgot about. In many cases, this mess can accumulate because people have pushed without being able to visualize what’s going on. My history has been much friendlier and cleaner since switching to GitKraken. Now it’s more of a nice tidy riGitoni instead of a messy Git spaghetti.

Bonus: GitKraken Frees up my terminal

Just because I’m using GitKraken, doesn’t mean I am ending my relationship with the terminal. In fact, GitKraken allows me to use terminal for other essential tasks like updating npm packages, starting/stopping processes, using vim to edit a file, or even to play a game of Zork without having 8 different terminals open.

What’s more, GitKraken can augment the way you work with your repos and, if you still want to launch the command line to scour the reflogs or to play some nostalgia 80’s text based games, just use the keyboard shortcut alt + T (Windows/Linux) or option + T (MacOS).