“You know my methods, Watson,” said Sherlock. “There was not one finder command which I did not apply to the inquiry.”
Okay, so maaaaaybe that’s not quite what Sir Arthur Conan Doyle wrote, but Sherlock’s detective skills surely inspired the new and improved Fuzzy Finder in GitKraken version 2.6.
With this release, we’re trying something a little bit different. We’ve put together a video—and this article—to cover what’s new. Watch the video or keep reading, the choice is yours! Let us know which you prefer.
Fuzzy Finder
To bring up the improved Fuzzy Finder, use the keyboard shortcut Cmd+P for Mac or Ctrl+P for Windows and Linux.
After you’re done looking into the curious incident of the dog in the night-time, you can use the Fuzzy Finder to perform any of the following actions:
Repo:
Init
Open
Open in file manager
Clone
Settings:
General
Git Config
Authentication
GitFlow
UI Preferences
View:
Toggle Left Panel
Increase Zoom
Decrease Zoom
Reset Zoom
Keyboard Shortcuts
History:
History + filename
The Fuzzy Finder has replaced the Command Palette; however, the old keyboard shortcuts Cmd+Shift+P for Mac and Ctrl+Shift+P for Windows and Linux, will still bring up the Fuzzy Finder.
The actions listed below were previously performed through the Command Palette, but can now be performed using the Fuzzy Finder:
Core:
Undo
Redo
File:
Stage all changes
Unstage all changes
Discard all changes
Stash:
Create
Pop
Apply
Branch:
Create
Fetch
Checkout:
Checkout + branch name
Additionally, if you click the search box in the upper right corner—or use the keyboard short Cmd+F for Mac / Ctrl+F for Windows and Linux—it will search through commits by default.
#GitKrakenTip: Use the Cmd+backspace / Ctrl+backspace shortcut to quickly clear out any searches or filters.
Other Updates
GitKraken will now politely inform you when you have an external rebase in progress. GitKraken will show this message and temporarily lock parts of the application until the external rebase has finished. You can still resolve conflicts from inside GitKraken at each step of the external rebase.
Lastly, we updated the macOS title bar color for both dark and light themes.
As Sherlock once sarcastically put it, “The world is full of obvious things which nobody by any chance ever observes.” We hope our Fuzzy Finder helps put things in plain sight so that you need not have Holmes’ mind to perform actions that are quite elementary. To see what else is new and improved in GitKraken v2.6, continue your investigation over in our release notes.
Today we’re excited to make two announcements! First of all, we’re introducing new, lower GitKraken Pro pricing for 1-user accounts. To make GitKraken Pro even more financially accessible for single users, we’re lowering the price from $60 to $49 per user per year. Woohoo!
We hope you’ve figured out by now that we really do listen to our users. The general feedback we’ve received is that $60 felt like a lot. Okay, problem solved; $49 it is! And, if you purchased GitKraken Pro individual licenses for $60 in the past 60 days, you can contact us for a refund of $11.
You know what feedback we haven’t gotten though? That our team prices were too high. In fact, we’ve consistently heard how inexpensive our team prices are! With that being said, we’re getting a little less aggressive with our team subscription discounts.
As of July 1st, 2017, we will be increasing our team subscription prices just a bit. For 10-99 users, the new price will be $39 per user per year instead of $30; 100-249 users will be $29 instead of $20; and 250+ users will be $25 instead of $20.
But, here is the cool part: If you purchase a team subscription prior to July 1, 2017, you’re guaranteed to maintain the lower price until July 1, 2018.
You’ll still get the best value by purchasing a team subscription after July 1st! And if your team has 250-999 users, our new 250+ tier provides a discount option that didn’t exist with our previous 1,000+ user tier.
Our second announcement is that we’re introducing GitKraken Enterprise! Essentially, GitKraken Enterprise will be identical to GitKraken Pro in terms of features, but it will be accessible behind a firewall.
The way the GitKraken client works is that it communicates with GitKraken servers to provide a number of services, including account and user management, authentication services, and updates to the client.
But for some organizations, having the GitKraken client communicate with outside servers is not an option; which is why we are introducing GitKraken Enterprise! GitKraken Enterprise will include a customer-hosted GitKraken Server, as well as a new version of the GitKraken client that communicates with the on-premise GitKraken Server.
We expect GitKraken Enterprise to be ready in late July of 2017. But in the meantime, we are offering a 30% discount for early adopters who commit to GitKraken Enterprise before July 31st!
Otherwise, the pricing after July 31, 2017, will be $79 per user per year for subscriptions of 100-249 users, and $69 per user per year for subscriptions of 250+ users.
GitKraken is a Git GUI client for Mac, Windows and Linux. Because it’s cross-platform, it’s essential that we practice continuous integration (CI) before we release. CI helps us catch issues earlier so we don’t have to wait to find out if our code is going to work.
We recently had to look for a new CI system after our old OS X system stopped building. The search began and ended rather quickly; These were our requirements:
Work simply
Work quickly
Be responsive
Be online
Have great uptime
OS X compatible
In our search, CircleCI seemed the most promising. It met all of our requirements and seemed easy enough to ramp up; so we gave it a go and it has been working quite well.
Top 3 reasons why we use CircleCI:
1. It helps us go fast
At GitKraken, we have a pretty ambitious release schedule, so we need to work quickly and efficiently. We can’t work fast if we’re waiting for our build server to well, build. Compared to our Linux and Windows systems, CircleCI works the fastest and reduces our iteration time.
The time it takes for the spin up to build, and run the build, is fast and more importantly, it keeps functioning like that. We hadn’t seen that level of speed in any of our previous CI servers.
2. It knows things
In other words, CircleCI is intuitive. For our dev team, the interface itself is very easy to use, setup and navigate. Everything is where you would expect it to be, and finding the stuff you need is a cinch, which reduces development time and makes our devs’ lives a little easier.
3. It’s dependable
Software can be a fickle friend. At the time we started using CircleCI, we were completely stalled for a few days because as I mentioned before, our old build server just stopped working. Our experience so far with CircleCI is that it works the second you ask it to start working and then it keeps working. Its snappy and reliable which makes our team want to bang our heads against hard surfaces a little less.
Summary
Frankly, we really like what they’re doing over at CircleCI, and we’re looking forward to them doing more. CircleCI consistently builds fast, it’s intuitive to use, and it just works.
Ideally, we’d like to move more of our build process over to CircleCI because it has the ability to build on both Linux and OS X. Unfortunately, CircleCI doesn’t currently allow for multiple operating systems on the same account.
One of my favorite mottos is “move fast and break things”. Unfortunately, when it comes to software, we tend to break things and not move very fast. The goal of agile development is to ship code at a higher velocity. The key is managing the process effectively enough to do so, while not breaking things—or at least, fewer things. In this article, I am going to provide some tips on how you can use the Scrum framework and fast feedback loops to increase velocity and improve quality.
Scrum development timeline by Axosoft
What is a Feedback Loop?
The most critical thing to creating good software is communication. Feedback loops are mechanisms that are used to validate and get feedback about the software development process. The goal is to get both positive and negative feedback that can be immediately fed back into the process. Doing this as fast as possible speeds up and improves the overall development process.
Types of Feedback Loops
Feedback loops are not all about verifying if the code you have written meets what the user wanted. Although, that is very important. It is also critical to know if your code works and is not full of bugs. Feedback loops are a mixture of daily best practices, automation, and tools. The last thing you want is for your users to be really excited about what you have done, and then be mad when it blows up all over the place.
Daily Scrum
Being able to quickly voice your progress and ask simple questions to your whole team is an excellent way to quickly share feedback. Simply mentioning what you are working on could spark a teammate to mention potential problems you may want to avoid. The Daily Scrum (sometimes known as the Daily Standup) is a good place to ask for feedback or help from your team so you can keep your project moving forward.
Meet With Product Owners & Users
Nothing is more important than user feedback. The last thing you want to do is spend a lot of time going the wrong direction. Meeting with product owners and users is critical, and it doesn’t have to take a lot of time. Try to avoid organized meetings which can be a big time suck. Instead, utilize email, Slack, etc., to constantly reach out for feedback.
Code Profiling & Tracing
What did your code just do? How does it perform? Developers now have access to some amazing tools that can help answer these questions in real time. As you are writing and testing your code on your workstation, you can get immediate feedback about how your code is performing and what it is doing. These application performance management (APM) tools can show you SQL queries, HTTP web service calls, errors, log messages, and much more. Check out free APM tools like Stackify Prefix, DevTrace, MiniProfiler, and others. They vary based on your programming language.
Unit Tests
Unit tests, integration tests, automated web tests, and others, provide a fast feedback loop. One of the apps I work on has over 100 complex integration tests. Anytime I make any changes to the code, I rerun all my tests on my workstation to make sure I didn’t break anything. Those tests are a critical fast feedback loop for me. There is no way I could make changes to that app without them!
Pull Requests & Code Reviews
Pull requests can help ensure that your code doesn’t get merged and deployed before it is ready. When lots of people are checking-in code non-stop, it can be hard to know if you are ready to do a deployment or not. Pull requests also provide a good opportunity to do some quick code reviews. Feedback from your team is essential to finding potential problems before you ship your code.
Validate Performance in Pre-Production Environments
Hopefully, your QA team does a good job of testing your applications. During the QA process, it’s a good time to look for application errors and review overall performance. Application monitoring solutions can help you do this. If your app does not get any traffic in pre-production environments, synthetic tests and load testing can help.
In a perfect world, you want to find software bugs before they get to production. If you need help tracking bugs, be sure to check thisbug tracking best practices guide.
Continuous Integration & Deployment
You can only ship code as fast as you can deploy it. Automating how you do builds and deployments is critical. It removes human error and speeds up the process. After you do a deployment, if need to quickly hotfix a bug, being able to check it in and do a fast, new deployment is important. Utilizing continuous integration to run your unit tests on a daily or continuous basis is also a very valuable feedback loop.
Monitor Performance in Production
You just pushed your new version to production. Congrats!! Now what? It’s a really good time to monitor production for new errors being thrown in your code. Odds are you will have a few. No matter how much you test your software before going to production, you will always find weird problems in production. Differences in customer data, traffic volumes, and hosting are all hard to test for beforehand.
Application monitoring is critical to finding potential problems as fast as possible. You should monitor overall performance to make sure your application is not running slower, using significantly more CPU, etc. These are potential problems that you can quickly detect and fix if you are using application monitoring best practices.
Tracking Product Usage
Do you know how many customers are using your new feature? Understanding how your product is being used is an important feedback loop. There are a few ways to do this.
You could use something as simple as Google Analytics, but if your app uses REST-style URLs, it won’t work well. If you are using an APM solution like Retrace, New Relic, App Insights, etc., they might be able to provide some insights into how often certain parts of your code get accessed. If you want advanced functionality, try Full Story. It looks amazing.
Summary
Every development team and software project is different. Your goal should be to figure out how fast you can go while maintaining high quality, and then go that fast. If going any faster reduces quality, then you have a good idea of where to let off the accelerator. Hopefully, some of these tips and fast feedback loops will help!
We created a series of Git tutorial videos that were really well received by developers wanting to learn Git. However, we got a lot of feedback that you (the viewer) wanted to see how those Git concepts could be applied in GitKraken. So, voila! We created the Learning Git with GitKraken video series.
Our latest video in this series is about squashing commits. In 90-seconds, you’ll learn what it means to squash commits, and you’ll see how easy it is to squash commits in GitKraken.
Ever wonder how you stack up against other Git developers in the industry? Do you sometimes get the sense that you’re somewhere in the middle of the pack when it comes to Git knowledge and experience? We surveyed developers to find answers to these questions, and to discover other Git trends!
Top 9 Git Trends:
1. Well, look at that! Two-thirds of developers consider themselves intermediate Git users.
While the other 21% consider themselves beginners and 13% advanced.
2. Two-thirds of developers use a combination of the CLI and a Git GUI.
22% use a GUI only and 11% use the CLI only. *Cough, cough* GitKraken is a great Git GUI if you don’t want to use the CLI exclusively.
3. Congrats, Octocat! Over one-third of developers host their Git projects on GitHub.com.
Followed by Bitbucket.com at 24% and GitLab.com at 11%. What do you know, GitKraken integrates with the top 3!
4. Two-fifths of developers use Git on Windows.
36% use Git to develop on Linux and 23% on Mac. We don’t like to pick favorites, so we develop GitKraken for all 3!
5. Half of Linux developers use Ubuntu as their distribution.
Followed by Debian at 15% and CentOS at 9%. You go Ubuntu!
6. One-sixth of developers use Visual Studio Code as their text editor of choice.
While Visual Studio, IntelliJ, Atom, and Sublime text are all tied at ~15%. Talk about a close race!
7. Sub-what? Over two-fifths of developers never use submodules.
28% use submodules rarely, 19% do sometimes, 6% do frequently, and 3% always use submodules.
8. Git-where? Almost two-fifths of developers never use Gitflow.
18% use Gitflow rarely, 17% sometimes, 15% frequently, and 12% always use Gitflow.
9. Git-who? Over two-fifths of developers never use Git hooks.
27% rarely use Git hooks, 18% sometimes, 9% frequently, and 4% always use Git hooks.
Survey data based on 642 responses from the GitKraken developer community.
Were you suddenly transported into an episode of Inspector Gadget after listening to that simple but catchy theme song? Okay, good! Now you’re in the right state of mind to dive into all the new bells and whistles GitKraken v2.7 has to offer. Watch this short video or keep reading!
Go-Go Fuzzy Finder
If you haven’t started using the Fuzzy Finder yet, now is the time because it’s even more efficient! Here are some of the new things it can do:
Start a pull request or create a tag.
Access the Gitflow panel.
Search Commits will take you back to the graph to view your selection if the graph wasn’t visible prior to your search.
Wowsers! Git Hooks
Now Git hooks are better, too:
The pre-commit Git hook can now modify the files of the same commit it’s running.
Git hooks that have control characters (like ANSI escape codes) are rendered correctly when their logs are displayed on failure.
On Windows, you can now browse for your sh.exe file for Git hooks.
More Gadgets
While some prefer tabs, we know that others prefer spaces. Let’s not get into the age old tabs-vs-spaces debate… Just know if you’re one of those people who would like to configure how many spaces should be rendered for tabs in diff view, you can now! Moving on…
Now, a quick right-click will give you the option to delete repos from the repository management panel. That’s a couple seconds of your life you just got back!
Local branches can now be renamed—because we all make tpyos.
Lastly, we’ve heard your requests for more feedback with blank diffs! So we’ve improved the following:
A filemode change will now let you know that the contents have not changed.
A whitespace change when Ignore Whitespace is checked will give you a heads up that you need to uncheck it.
A binary file change will tell you that GitKraken can’t display those.
As always, check out our release notes for more details on bug fixes.
We’ll start by answering the question: what is SSH? SSH—also known as Secure Shell—is a network protocol that allows one computer to connect to another computer over an unsecure network, like the internet.
Sounds simple, right? Well, it get’s a little more complicated once you get into the details of SSH clients, SSH servers, and public and private keys. That’s why we put together this video to show you what SSH is, how it works, and what role GitKraken plays with SSH.
Zapier is a powerful automation service that can fetch data from hundreds of supported applications and post to your Axosoft account. You can also have new items in your Axosoft database trigger updates and post the new data to any of Zapier’s applications, like Toggl, Google Calendar, Github, and more. Each automation point is called a Zap, and they’re incredibly easy to setup and maintain.
Popular Zaps
One popular Zap is between Axosoft and Toggl. Toggl’s Chrome extension makes time tracking easy! A user can simply start and stop a timer from inside the Axosoft interface, and this Zap will automatically add a work log in Axosoft.
With the Trello and Visual Studio Online Zaps, whenever an item is created in Axosoft, you can automatically create a work item in Trello or Visual Studio Online.
Axosoft users also love using our Google Calendar Zap. Rather than going through all of your releases in Axosoft to show timelines and overlapping releases, use Zapier to automatically push new releases to your Google Calendar.
Custom Zaps
You can also make your own Axosoft Zaps with triggers and actions.
Triggers
New Item: Triggers when a new item is created.
New Release: Triggers when a new release is created.
New Contact: Triggers when a new contact is created.
New Project: Triggers when a new project is created.
New Customer: Triggers when a new customer is created.
New Work Log: Triggers when a new work log is created.
New Email: Triggers when a new email is created.
Actions
Create Project: Creates a new project.
Create SCM Post: Posts the SCM commit data to any of your tagged items.
Create Contact: Creates a new contact.
Create Work Log: Creates a new work log.
Update Item: Updates an item.
Create Customer: Creates a new customer.
Create Item: Creates a new item.
Note for Axosoft Installed users:
Use the Zapier app dedicated to Axosoft Installed accounts.
Unless you can write something perfectly the first time, you need to have a version control system. A version control system (VCS) is a tool that helps keep track of changes across versions of a file or group of files.
For most people, their first VCS is duplicating the file with a different file name. If you’re writing a document, this might look like having different files named outline.docx, draft.docx,draft-v2.docx, draft-v3.docx, and final-draft.docx. This is a perfectly valid VCS, and it works well for simple workflows. However, life isn’t always simple, and complicated workflows are made less cumbersome with a robust VCS.
While there’s no one-size-fits-all solution for organizing files, Git is a great choice for many workflows. Git might not transform your life, but it will change your hard drive!
Git has established itself as the most popular VCS. But despite its profound usefulness, it just hasn’t made it into the high school curricula yet, and students aren’t using this amazing tool for their academic workflows.
While Git can be challenging for the uninitiated, a user can get up and running in almost no time if they install a well-designed Git graphical user interface (GUI) like GitKraken.
I love the visual tree that GitKraken provides.
I’ve been working with Git ever since high school, and despite years of experience, I still find myself using a GUI to streamline many of the workflows I use in grad school. I’m pursuing a PhD in Electrical Engineering at Stanford University, investigating how lasers can be used for inertial navigation of aircraft. My research seeks to make fiber optic gyroscopes more accurate and less expensive.
In this article, I will share three Git workflows that Git and GitKraken have made much more streamlined. While one could use any Git client for these workflows, in my experience, GitKraken stands out as the most elegant solution for cross-platform version control.
1. Versioning Code for Research Experiments
If you’re a grad student, the odds are pretty good that you’re doing research. If you’re a grad student and you’re reading this blog, the odds are pretty good that you write code for your research.
My research project involves an algorithm that is used over and over again. The MATLAB code for the algorithm was written by a grad student over five years ago and has since been improved by other grad students. Every so often, when we are comparing experimental results with previous results, we ask the question: “which version of code created these plots and got these figures?”
For a while, when a student would update the algorithm, they would just include a comment at the top of the file, such as this:
% Title: Allan Variance Calculator
% Author: Grad Student A
%
% Modified to allow for different types of optical sources. – Grad Student B, 8 April 2014.
% Optimized nested-loop for faster performance with large datasets. – Grad Student C, 21 October 2016.
func foo(bar)
...
The problem with this approach is that you lose the original code and can’t go back to it if something breaks. One could preserve the original code in another file such as script.m, script_v2.m, script_v2_grad_student_a_edits.m, but this approach quickly becomes unwieldy.
This is a use-case where Git shines. Suppose I was looking at a dataset that was created back in 2013, and wanted to recreate the plot using the same code the 2013 grad students used.
I could type git log into my terminal, and dredge up the name of the commit that was used in 2013, and then type git checkout <commit name> to temporarily use the code that those students used. Afterward, I could type git checkout HEAD to restore back to the current version. This workflow is much easier and makes it a breeze to compare the outputs of all the different versions of a script.
GitKraken is indispensable for debugging complicated programs for school assignments, cherry picking, and committing hunks of a file.
GitKraken doesn’t support checking out old commits, but it does make viewing changes across the entire directory—and in single files—heaps easier than remembering the dozens of arguments for git log.
2. Versioning Code for LaTeX Publications
There are lots of reasons to use LaTeX for writing in grad school. If you’re writing a short and simple document, Google Docs is usually sufficient. But for more complicated documents, LaTeX is unparalleled in its support for vector drawings, equations, and reference management.
Because LaTeX is a programming language, it lends itself particularly well to version control—so much so that popular LaTeX hosting sites like Overleaf provide Git repositories for each LaTeX project.
When I write, I hate to throw away paragraphs during the revision process. For a long time, I would strike out large sections in my Word documents or I would keep separate files full of paragraphs that I had removed while editing, just in case I ever wanted to bring them back in later versions.
In LaTeX documents, it was even worse: my code was stuffed with vast sections of commented-out paragraphs, interspersed only by the occasional uncommented section here and there.
When I introduced Git into my workflow, I found I could delete these unused paragraphs out of my documents, and if I ever needed to go back to them, they would be sitting in previous commits. As the clutter in my drafts decreased, the readability increased, and I was always confident I could restore a previous “working draft” within seconds if needed.
For collaborative writing, Git works well when you want to merge changes from different users.
For text files, Git automatically does most of the merging for you automatically. The only time where user intervention would be required is if two edits were made to the same paragraph, in which case the user couldn’t merge the two automatically. In these cases, using a GUI saves a lot of time. GitKraken has a beautiful in-app merge tool to make it easy to resolve merge conflicts.
3. Building Your Code Résumé on GitHub
Eventually, students graduate and enter the workforce. I study at Stanford University, in the heart of Silicon Valley, and having coding skills on your résumé upon graduation is paramount for most of the big companies in the area.
GitHub has become the platform of choice for showcasing coding projects to potential employers. So, with that in mind, I try to make a point of publishing code for school projects on GitHub whenever I can (with the notable exception of homework assignments, where it would violate academic integrity policies).
Knowing that my code will be published on a public website forces me to write better code.
I’ve found that I tend to write descriptive comments, use best practices, and get in the habit of organizing my changes in small commits. This makes every school project an opportunity not only to earn a high mark in my class, but also to practice for a successful career in coding if I want to pursue that route down the road.
I find that only about half of my personal code review happens when I’m in my editor. When I’ve finished writing my changes, and the code works the way I want it to, I’ll fire up my Git GUI and read over what the commit will look like.
It’s at this point that I start seeing all the styling errors and unclear comments, and I go back and fix-up my code. I’ll also find some times that a commit could be broken into two different commits. For example, I’ll split the changes from a “fixed button and updated algorithm” commit, into a “fixed button” commit and an “updated algorithm” commit.
Why Should Grad Students Use Git?
I would recommend using Git if any of the following are true for you:
You manage a repository of code for an ongoing experiment or project.
You write a lot of complex or collaborative documents in LaTeX.
You might need a portfolio of coding projects in the future.
Git is a powerful tool, but it can have a pretty steep learning curve. Using a Git GUI simplifies the workflow and makes using Git a lot more intuitive.
After comparing different GUIs, I switched to using GitKraken for all of my own projects, and it’s the GUI that I recommend regardless of OS or prior experience with Git. It doesn’t support detached heads or issue tracking yet, but that doesn’t keep it from being the best Git GUI out there for versioning code—both in and out of grad school.
I got started with GitKraken Pro and GitHub through the Student Developer Pack. With the pack, students get free access to the best developer tools! GitKraken Pro includes all the regular GitKraken features, plus things like an in-app merge conflict output editor and multiple profiles. And GitHub provides unlimited private and public repositories. Eventually, I will explore Stripe and Travis CI, which are other valuable tools in GitHub’s Student Developer Pack.
We’re excited to announce that you can now super size your files because Git large file storage (LFS) support is available in the GitKraken v3.0 release!
Nothing makes us happier than making your feature requests and social media wishes come true. And while I’d love to highlight all of our LFS super fans on social media, we have a special place in our hearts for Nicola and Gabriel…
Facebook wishes granted! Stay in touch guys <3
Git LFS
Check out this short video to see how LFS works in GitKraken or just keep reading.
To get started with LFS in GitKraken, you’ll need to have Git LFS installed. Then, in GitKraken, navigate to Preferences > LFS BETA >initialize LFS on this repo. You’ll also want to specify the file types for LFS to track.
Once initialized, you’ll see an LFS icon in the toolbar which you can use to interact with files on your LFS server.
Any files tracked with LFS will be marked with an LFS icon in the right panel. When you click to view the diff of the file, you will see the SHA reference instead of the file itself.
You can now multi-select files in the right panel! Simply select a file and then hold Shift to select a range or use Cmd/Ctrl to multi-select individual files.
Improved Right Panel Performance
We’ve improved navigation with arrow keys in the file tree view and scrolling through the file list in the right panel.
GitKraken Enterprise? GitKraken Pro? How you use GitKraken will be primarily based on your security requirements and preferences.
Our Enterprise Customers
Government agencies, financial institutions, and hospitals are examples of customers that benefit from our Enterprise solution.
Our Enterprise Customers:
Work in a sequestered, intranet environment where security requirements dictate that computers do not communicate outside of the company network.
Manage user authentication on their network, and update GitKraken versions on their own schedule.
Host a Linux server running a local version of GitKraken’s server functions.
GitKraken Enterprise and GitKraken Pro do offer the same functionality, but our GitKraken Pro users have a different network configuration and security requirements from the Enterprise model.
Our Pro Customers
Our GitKraken Pro customers are spread across many industries and include companies such as Apple, PayPal, Netflix, Starbucks, Ford, and SAP.
Our Pro Customers:
Integrate their remote repositories with products such as GitHub, GitLab, or Bitbucket.
Manage subscriptions and users on our server.
Get automatic software updates installed on Windows and Mac. GitKraken Linux users are notified with the message below, in the lower left-hand corner of their app, when updates are available.
Which is the Right Choice?
Enterprise or Pro, it’s really a matter of where you keep your repositories and user info. What are your security needs and preferences? If your assets are all in-house, let GitKraken Enterprise help you. Repositories live away from home? Go Pro.
Once again, we are sponsoring GitHub Universe, and we’re looking forward to seeing YOU! You’ll find us at this year’s GitKraken sculpture, where our GLOing team will be ready to fill your tentacles with swag! Why? Because we love GitKraken supporters and want you to be the best dressed in the Universe!
How To Get Swag
Other giveaways:
Lightup GitKraken fidget spinners
GitKraken tattoos
Tokens for the vending machines
Can’t-Miss Experiences
AskMeAnything (AMA) with Ed Thomson on October 11th, at 2 pm. Join us in the GitKraken Slack community—especially if you can’t attend GitHub Universe—to ask Ed about his talk and anything else! If you’re not a member, join the community here: https://slack.gitkraken.com/
Join GitHub Trainer Hector Alfaro on Tuesday, October 10th, at 11:40 am, to hear his talk on “Common Challenges with Git in teams.”
Don’t miss Chilumba Machona, Founder of Agrisave, who will be discussing “How Agrisave is Using GitHub to End Hunger”. Date and time for the talk to be announced.
Check out “Electron: Start to Finish” with Eric Hollenberry and Nathan Henderson, on Wednesday, October 11th at 2:10 pm. Psst! GitKraken is built on Electron!
Support Maven
And, of course, you won’t want to miss the Universe After Party on Wednesday, October 11th; it’s a benefit concert for Maven! Maven empowers LGBTQ+ youth in the arenas of social change and technology.
GitKraken is also partnering up with Maven to donate $10 of any GitKraken Pro purchase between Wednesday, October 11th, and Friday, October 13th. Our promo code will be announced on October 11th, so stay tuned!
There’s now a full-file contents view when viewing a diff of a commit. Users are able to toggle between viewing solely the diff hunks with changes, or the entire file with the changes applied.
External diff tools are now supported
Set the tool you prefer to use for viewing diffs in Preferences > General.
The commit panel got a makeover
The trash can replaces the “Discard All” button. This should reduce the chance of accidentally discarding when you are staging changes.
Wash the dishes, do the dusting,
Do the staging, make the commits!
When viewing the working directory, the new panel header will tell you how many files have been changed and display the name of the branch.
The toggle button allows the commit panel to be pinned to the right or bottom of the window as you prefer.
1. The toggle button for the commit panel. 2. The new panel header.
Keiferella’s new look also includes:
Easy to see scrollbars throughout the app.
Background colors and other styling improved for both light and dark themes. Improved text contrast and differentiating code views from other panels in the application.
When viewing a commit, the SHA for that commit is displayed in the new panel header (and copyable with a click).
When in a conflicted state, messaging will now correctly reflect whether the state was the result of a rebase or a merge. The branches involved are now also styled to match their labels in the graph.
The list/tree view dropdown menu has been replaced with a new toggle button.
Quickly jump to your working directory when viewing older commits, with a new shortcut that appears at the top of the commit panel.
Now you can collapse the unstaged and staged files sections to make more room for viewing file changes in the commit panel.
A checkbox to view all files is now available when viewing a previous commit. This allows you to browse and view all files in a repository as they were at that commit.
Linux users, this one is for you! Update buttons are much easier to see now.
A checkbox to view all files is now available when viewing a previous commit. This allows you to browse and view all files in a repository as they were at that commit.
We added a context menu option to copy a branch’s name from the left panel or the graph.
We’re proud of GitKraken’s unique aesthetic. Our beautiful Git GUI stands out. The tale of how GitKraken rose from the sea is a reflection of us as a company; here’s how our company culture inspires the products we design.
Design Inspiration
GitKraken has really evolved since its start as a 30-day project, but it maintains some consistent themes.
Beauty matters to us. Our team of designers and developers are also artists. When concepting GitKraken design elements, they were inspired by sci fi images and subway maps because of the way in which information is displayed. Look familiar?
We were able to concentrate on building a product that is intuitive by analyzing what was already out there, and then rethinking industry standards by drawing inspiration from other mediums that have proven to be successful in terms of UI/UX.
We wanted to build a Git GUI that provided a consistent experience across Windows, Mac and Linux. So we did, by utilizing Electron, which at the time was a very new technology gaining rising adoption.
We wanted you to have drag and drop ability like no other Git GUI because we knew this would improve productivity.
We designed the visual graph and commit message text for easy readability. Our branch/tag labels are on the left side of the graph, so they’re easier to read and interact with (for example, dragging and dropping). This allows for the commit messages to be displayed in a separate column, left-aligned. In our graph, branches stay in their own column until they merge back into another branch. All of these design considerations make reading the visual graph info and the commit message text much easier, setting GitKraken apart from other Git GUIs.
GitKraken: The Invertebrate with a Spine
Our company, Axosoft, is intentionally structured to be… well… unstructured. We’re at the office. We work together face to face, every day. We collaborate and discuss—all of the time. We sit (or stand) near people that own similar responsibilities to ours. Slack is our primary communication exchange in the office—so our conversations are most often company wide. Everyone in our company has valued input, regardless of topic and position. This is how we move fast. Make fast. Deliver fast. (OK, and catch a mistake here or there…and fix it…fast!)
We’re all considered leaders, responsible for our part in shaping the direction of our product. We have a wee bit of management structure, but we keep as close to a flat hierarchy as possible to maximize the efficiency in communication and ownership of our product.
Our Sea World
Our habitat is meant to delight the eye. Foster creativity. Stimulate thinking. To be beautiful and inspire beauty.
Travel is valued highly here—so much so that we’re sent away to admire what makes up our planet.
As a company, we look to what’s visually delightful. We developed GitKraken with visual organization- so you can take your mind off version control worries and concentrate on what you are developing.
The Dog Food Club
How do we know what you need so well? We eat our own dog food here. GitKraken has evolved successfully because we use our own Git GUI to manage our code. Of course, developers are developing GitKraken while using GitKraken, right? In addition to our dedicated user experience sessions, we use GitKraken to develop GitKraken, so our product is constantly being tested.
We take none of this for granted. We’re by your side, creating a beautiful product to help you create beautiful products, too.
Welcome to our most popular videos playlist for learning Git. Here you will find the most instructional (and the most entertaining) ways to get the most out of Git and GitKraken. This playlist is dedicated to all you Git beginners who are ready to start versioning away. Enjoy!
#1: Set the Mood
See how video killed the radio star—or how our Git GUI client stole the hearts of developers across the world. To get a sense of what you’re getting into with GitKraken, watch this quick and humorous 30-second introduction to the Git GUI client that’s an 80s legend and so much more!
#2: Get Started with GitKraken
Have repos ready to init in GitKraken? Watch our GitKraken Tutorial for Beginners, and you’ll have the basics down faster than you can remember your favorite mixtape.
#3: Learn about SSH
Watch this Git tutorial video to learn what SSH is, and how GitKraken uses it to communicate securely. GitKraken and SSH—two tickets to paradise.
#4: Use GitHub with GitKraken
Make yourself comfortable and settle in for one of our most popular videos on how to integrate GitHub and GitKraken. Watch this video to find detailed information on authentication, managing remotes, and working with pull requests.
#5: Implement Gitflow
This is a great 3-minute introduction to the critical process of Gitflow. Watch it now:
Subscribe to our YouTube channel for more great videos on learning Git, GitKraken, and more!
GitKraken now comes with a Favorites list for your repos. From the Open Repository menu or the Breadcrumbs menu, you can favorite as many repos as you want!
Multi-select discard
We’ve added multi-select for discarding changes; it works the same as multi-select for Staging and Unstaging. While you’re discarding, notice the context menu—you can now discard all changes within a folder in tree view.
More treats
We’ve added a context menu option for updating submodules.
Now use Ctrl + D (Windows/Linux) / Cmd + D (Mac) or the Fuzzy Finder to open your configured external diff/merge tool.
Check out our release notes for the swept away spiders, er… the bug fixes! ️ Happy Halloween!
The newest video in our GitKraken Tutorials and Tips series is “How to Manage your Git Workflow with Forks in GitKraken”. Creating a fork from the original project allows you to make changes to a project without altering the original repository. In this way, multiple people can develop forks off of the master repository without altering it until it is time to merge the commits.
In this video, you will see how to create a fork and then how to make changes to the fork in GitKraken. After watching this video, you will be able to clone a forked repo, checkout a branch you want to add a feature to, and create a pull request to get those changes into the master repository.
Our Git GUI’s visualization of the development process is so elegant, you’ll want to collaborate just to watch the graph evolve!
Subscribe to our YouTube channel for more GitKraken tips and Git tutorials!
Meet Juan Chaves. He is a lifelong techie, a veteran that has served our country for over five years, and a GitKraken user.
While serving in the military, Juan developed strong management and leadership skills. He is now turning his lifelong passion for technology—and more recently acquired leadership skills—into a tech career; he’s currently working towards his Master’s degree in Cybersecurity and Leadership.
When our veterans transition from military life into civilian life, the loss of the military support network is a profound and often difficult adjustment. Navigating a new career path post-military provides additional challenges.
Enter Operation Code, an organization dedicated to supporting military veterans and their families in launching careers in the technology sector. Operation Code fills the void with a valuable community and career services.
Juan learned about Operation Code while he was enrolled in coding boot camp and continues to be active with the organization as a graduate student. They offer 1:1 mentorship, a supportive online community, and employment services as our veterans and their families transition into their next chapter.
On Friday, November 10th, Operation Code is hosting a Benefit Dinner and Auction. This event aims to raise funds the non-profit organization needs to help their community of over 3,000 military service members, guard and reserve troops, veterans, and their spouses and families, with services like the Software Mentor Program, tech conference scholarships, career support, networking and other resources.
Juan finds Operation Code’s online community particularly helpful. Anytime an Operation Code member wants to talk out a technical problem and discuss approaches towards solutions, an international, around-the-clock, online community is available as a sounding board.
It [GitKraken] really helped me grok what the Git process is like and what the commands mean [in the terminal].
Juan Chavez
Juan’s advice to fellow veterans: “Don’t be afraid to pursue tech; it’s going to be rough, but you got through boot camp. If you’re interested in this transition, immerse yourself in technology for a year, and don’t tell yourself that you can’t do it.”
We’re proud to support Operation Code through sponsorship and providing our Git GUI client as a resource for making learning Git a little more intuitive.
Are you looking for tutorials, tips and organizational tricks for using Axosoft? Well, you’ve come to the right place! Here are our 10 latest Axosoft Tips.
Turn on the tutorial bar and select a topic to get better acquainted with the UI.
Create subitems to break your work into more manageable parts.
To edit existing custom fields, select the field to be edited and either click the Edit button or double-click the field name.
Use the Organize Panel to quickly filter your work logs tab (and your other tabs).
Move the Organize Panel panes up or down to reposition them.
Right-click on any group header to quickly expand or collapse all groupings.
File size is available as a column when you dock the Attachments pane to the bottom pane.
Organize your many email account connections by renaming the email account name.
Use the quick add + to create sprints or releases on the fly!
When creating a new item, search for existing items with the same name to avoid creating duplicates.
If you keep on believing
What’s the matter?
Download GitKraken v3.2 
️
