Mac Dev Survey 2022 — The Results

2,506 developers working on the Mac answered the call and took part in our 2022 survey. Besides working through 26 individual questions, they also answered a more far-reaching question: Who are we as a community?

March-April 2022
2,506 participants

Developer Profile — 1/4

Age and work experience

As before, the majority of our partcipants are in their thirties or forties, meaning that the average developer on the Mac has quite some experience to draw on!

Age (years)

Work experience (years)

Developer Profile — 2/4

Geography

Our community really spans the world! People from more than 90 countries took part, from India to Iceland and from Australia to Argentina!

Developer Profile — 3/4

Company size

Mac developers work in all sizes of teams, many of them at either extreme end of the scale. It's fascinating to see that almost half of our participants work either solo or in companies of 500+ people!

Developer Profile — 4/4

Actual programming time per day

Despite the number of tasks knowledge workers have to handle, two thirds of developers manage to spend more than 4 hours each day actually coding. A tenth of participants regularly get in more than 8 hours of coding a day.

Tech and Languages — 1/5

What type of development do you mostly do?

A large majority of our participants work with web and mobile. Data engineer, an option we added this year, received 1.7% of responses.

Tech and Languages — 2/5

Is design part of your role?

We thought it would be interesting to know to what extent the average Mac developer also handles design-related tasks, and the picture is clear: more than 80 % of participants do at least some design work!

Tech and Languages — 3/5

Do you contribute to open source on a regular basis?

It's very cool to see that almost 60% of our community contribute to Open Source projects, with 1.7% doing Open Source as their main type of work!

Tech and Languages — 4/5

Do you write unit tests for your code?

Unit testing is clearly an established practice, with over two thirds of developers spending at least some of their time writing unit tests!

Tech and Languages — 5/5

Which programming languages do you work with the most?

Given the focus on web and mobile among our participants, it comes as no surprise that the most used programming languages are JavaScript, Swift and CSS. Interestingly, TypeScript usage increased by almost 4 percentage points compared to last year!

Win one of our macOS t-shirts!

Help spread the word about our survey results and get a chance to win one of ten t-shirts by tweeting:

2022 Mac Developer Survey: the results from over 2,500 Mac developers are in. Tools, programming languages, and more 👉 https://www.git-tower.com/blog/mac-dev-survey-2022-results #macdevsurvey2022

Tweet Now!

Learning — 1/3

Which languages would you like to learn?

Swift and Rust are the languages Mac Developers are most interested in learning! For this year's survey, we added Kotlin, the preferred language for Android development according to Google. Clearly, quite a few people are curious about Kotlin as well!

Learning — 2/3

From what kind of sources do you prefer to learn?

For this year, we corrected an omission from last year and added Official Documentation as an option. Thankfully, this quickly rose to the top along with blog posts and courses!

Learning — 3/3

What are your favorite development news sources?

The answers submitted range from old classics to new contenders. Here's a sample from the hundreds of different sources you shared with us: freeCodeCamp, Dev.to, Hacking with Swift, Laracasts, Traversy Media, Rachel Andrew, daily.dev, Wes Bos, Swift by Sundell, Ars Technica and HackerNoon.

Development Tools — 1/3

Which code hosting platform do you use?

GitHub remains the most popular code hosting platform by far. Interestingly, well over a tenth of participants choose a self-managed solution or don't use a code hosting platform at all!

Development Tools — 2/3

Which text editor do you use?

Given the popularity of JavaScript and Swift, it's no surprise to see Visual Studio Code and Xcode at the top of our poll. Quite a few in our community use the command-line modal editor Vim!

Development Tools — 3/3

Do you use a tool for diffing and merging?

Almost half of us don't use a dedicated tool for diffing and merging. Among those who do, however, Kaleidoscope and the default File Merge app are the tools of choice!

Productivity and Tools — 1/6

Which tools do you use to track bugs & issues?

Jira is still the number one choice when it comes to issue tracking. Trello, an option we added this year, is used by almost a tenth of participants.

Productivity and Tools — 2/6

Do you use a tool for task management?

JIRA is not only popular for tracking issues, but also for general task tracking. Interestingly, GitHub Projects, an option we added this year, quickly occupied second place!

Productivity and Tools — 3/6

Are you using a file-sharing solution at work?

Google Drive remains the dominant file-sharing solution, with Microsoft OneDrive in second place. Dropbox is roughly as popular as using no file-sharing solution at all!

Productivity and Tools — 4/6

Does your team use some kind of intranet for shared documentation?

Atlassian is well represented in this section, providing not only Jira but also the most popular intranet solution; Confluence. In this one, it's Google Drive which is roughly as popular as using no bespoke solution at all!

Productivity and Tools — 5/6

Which workflow or tool do you struggle the most with?

As you can imagine, this question received many wildly varying answers! A pattern emerges, though: Jira, Git and CI/CD cause developers to struggle the most.

Productivity and Tools — 6/6

What's your favorite development tool?

As the conductors of this survey, we're happy to see so many mentions of our Tower Git client! However, many other tools are dear to our developer community: Visual Studio Code, Xcode and, interestingly, relative newcomer Nova!

Not So Serious — 1/2

Do you listen to music when working?

Last year's survey left no room for doubt: an overwhelming majority of developers listen to music at least some of the time while working. This year, we asked what kind of music you listen to. Unsurprisingly, electronic music came out on top, closely followed by rock and pop. Classical music is in fourth place, coming in ahead of hip hop and jazz!

Not So Serious — 2/2

What's the best commit message you have ever read or written?

Clearly, there's wisdom in commit messages! Our survey participants have encountered a lot of interesting ones... like, for example, this one:

$ git commit -m "This will come back to bite us"

$ git commit -m "I forgot how to squash, so here's another commit"

$ git commit -m "Worked it and twerked it"

$ git commit -m "it works, but shouldn't. plz help"

$ git commit -m "No, THIS is the final commit"

$ git commit -m "Didn't like it but had to commit this"

$ git commit -m "Somebody fix this."

$ git commit -m "God only knows.. I don't"

$ git commit -m "Revert fix typo"

$ git commit -m "Regaining order, saving sanity, and moving towards a brighter future"

$ git commit -m "Dave breaks it Steve fixes it that's our workflow"

$ git commit -m "This is the ninth attempt at rebasing"

$ git commit -m "Ok I promise this time it will work"

$ git commit -m "Nothing to see here, move along"

$ git commit -m "This should not be committed but can not argue with manager"

$ git commit -m "Fix bug but its not work"

$ git commit -m "This change may not work for everyone."

$ git commit -m "Now fixed for real"

$ git commit -m "Removed all errors"

$ git commit -m "This works... trust my instincts"

$ git commit -m "crossing fingers, toes, and anything inbetween!"

$ git commit -m "Reverting the reversion of the reversion"

$ git commit -m "Decreasing Coverage threshold, will increase back, promise."

$ git commit -m "explain me if you understood my code"

$ git commit -m "yoloing this b/c its friday!"

$ git commit -m "fix not sure"

$ git commit -m "If it breaks, it breaks"

$ git commit -m "Well you can tell by the way I use my threads I'm synchronized, no time to spin."

$ git commit -m "Fixed xxx again, please don't unfix it anymore."

$ git commit -m "Unset tripple negative false"

$ git commit -m "fine, you win rubocop"

$ git commit -m "and then a miracle occurred."

$ git commit -m "Once more, with feeling!"

$ git commit -m "Hello, please merge!!!"

$ git commit -m "bugfix: I really don't know what I was thinking at the time"

$ git commit -m "Fixing the stuff I broke earlier"

$ git commit -m "I don’t know why I had to commit this"

$ git commit -m "I don’t know why it works, but it does"

$ git commit -m "Does some stuff idk it works now"

$ git commit -m "Dont worry, this will not break the prod"

$ git commit -m "I've broken all unit tests and by passed the commit hooks"

$ git commit -m "don't know why but its fixed"

$ git commit -m "Cha cha changes"

$ git commit -m "Beautified code in the desperate hope of improving app performance through increased self-esteem."

$ git commit -m "Well that's not gonna work"

$ git commit -m "fixed for real"

$ git commit -m "DOH! undo that"

$ git commit -m "It was already broken when I arrived."

$ git commit -m "IDK just push changes"

$ git commit -m "Jerry reserves the right to say "I told you so""

$ git commit -m "For the sake of my sanity, just ignore this…"

$ git commit -m "I don't know what i've done, but it works now"

$ git commit -m "Scott was here"

$ git commit -m "semi-final commit"

$ git commit -m "short hack, don't forget to refactor later!"

$ git commit -m "Maybe this time"

$ git commit -m "fixed it, again, the 3rd time"

$ git commit -m "Faster loading time by decreasing countdown timer"

$ git commit -m "i'll explain later"

$ git commit -m "no one will read this anyway"

$ git commit -m "I was forced to write this crap"

$ git commit -m "assumption is the first bug"

$ git commit -m "Copy-paste to fix previous copy-paste."

$ git commit -m "This work but not compile"

$ git commit -m "I am committed"

$ git commit -m "made irreparable improvements"

$ git commit -m "devs don’t let devs commit drunk— at least not alone"

$ git commit -m "I didn't this"

$ git commit -m "This Is Why We Don't Push To Production On Fridays"

$ git commit -m "I hope this works, this time"

$ git commit -m "undo initial commit"

$ git commit -m "Well that should work"

$ git commit -m "I don't understand how this works, just don't revert this one"

$ git commit -m "fixed the fix"

$ git commit -m "I hope this pig will fly"

$ git commit -m "hand-coded... updated, all shiny and new"

$ git commit -m "This time real real v2"

$ git commit -m "Do not merge this"

$ git commit -m "test commit please ignore"

$ git commit -m "Ignite the flames"

$ git commit -m "I'm so so sorry about this"

$ git commit -m "Literally nothing. Need to trigger pipeline again."

$ git commit -m "Semiblind attempt to fix customer's issue"

$ git commit -m "One small step for me, one giant mess for the project lead."

$ git commit -m "Fixed some bugs, added some new bugs to be fixed later."

$ git commit -m "Build working, for real this time."

$ git commit -m "hot fix of hot fix"

$ git commit -m "chore: embellish code"

$ git commit -m "Today I could finally see the banana"

$ git commit -m "This should work, merge to production"

$ git commit -m "I did this the other way."

$ git commit -m "This will fix definitely fix it v3"

$ git commit -m "Drunk, fix later"

$ git commit -m "Fix this on monday"

$ git commit -m "Hallelujah!"

$ git commit -m "No, really, dates are fixed this time!"

$ git commit -m "If you think there are no more bugs left, you have to fix the bugs left."

$ git commit -m "this one should work"

$ git commit -m "bunch of sad tests are happy now"

$ git commit -m "Stupid demand, but have to do it"

$ git commit -m "You have successfully completed you task. You deserve a badge because you did your best."

$ git commit -m "this'll fix everything"

$ git commit -m "[HOTFIX] Revert pointing all configs at production"

$ git commit -m "Revert: Revert: Revert: Revert: …"

$ git commit -m "OK, take #23. It's 5am... and it works. For real."

$ git commit -m "Hopefully, maybe, fix X, please?"

$ git commit -m "Change this and get your tires slashed"

$ git commit -m "What could have been done with a few lines of code we have instead replaced with a pile of Javascript"

$ git commit -m "So long and thanks for all the fish"

$ git commit -m "not sure what I added here lol"

$ git commit -m "yolo"

$ git commit -m "final.final.final commit"

$ git commit -m "I broke a thing... but it works."

$ git commit -m "Fixes #2446, but I don’t know why"

$ git commit -m "Fix Skynet attack"

$ git commit -m "goddammit david"

$ git commit -m "Fixes all the bugs (deletes all files in repo)"

$ git commit -m "Fixed all the broken things"

$ git commit -m "Remove all tests"

$ git commit -m "Don't look - Just approve!"

$ git commit -m "Do Not do this Again!"

$ git commit -m "I have done the needful"

$ git commit -m "Finally, it's working, now I may sleep…"

$ git commit -m "if this breaks anything, breakfast is on me"

$ git commit -m "final, final, final, final candidate"

$ git commit -m "Oh god, how did this ever work before"

$ git commit -m "Proper functionality should now throw errors."

$ git commit -m "Rolling back because I made a terrible mistake"

$ git commit -m "This wasn't me"

$ git commit -m "I don’t care anymore"

$ git commit -m "fixed some bugs, added more bugs"

$ git commit -m "jQuery makes Jake weary"

$ git commit -m "Fixing the typo introduced in the previous fixing the typo commit"

$ git commit -m "Let's YOLO this thing, I trust my skills."

$ git commit -m "TODO: Fix this later"

$ git commit -m "The thing now does the thing that the previous thing thought the thing did (bugfix)"

$ git commit -m "At some point we'll make Jenkins happy. That day is not today."

$ git commit -m "Revert: fix for the fix"

$ git commit -m "Not my fault"

$ git commit -m "Fix cat walking over the keyboard"

$ git commit -m "Oops i did it again"

$ git commit -m "Fixed the fix…again"

$ git commit -m "You are here"

$ git commit -m "If this doesn't work, find me at the bar. If it works, find me at the beach."

$ git commit -m "Now witness the power of this fully armed and operational web hooks battle station. Fire at will, commander."

$ git commit -m "Fix banana bug."

$ git commit -m "really fix danger for this time"

$ git commit -m "My name is Ozymandias, king of kings. Look upon my changes ye mighty and despair"

$ git commit -m "Revert previous revert again"

$ git commit -m "It was hard to write so it should be hard to read."

$ git commit -m "Dear future fellow developer: Don't blame me"

$ git commit -m "I apologize now to the future maintainer"

$ git commit -m "Note to future self: take a week and fix this."

$ git commit -m "I'm leaving so it doesn't matter"

$ git commit -m "Now that I'm in charge around here, there's going to be some changes"

$ git commit -m "I accidentaly destroyed the solution"

$ git commit -m "this is the revert to the previous revert and the other revert"

$ git commit -m "i have no idea how doing this makes it work."

$ git commit -m "Actually, actually fixed"

$ git commit -m "See previous."

$ git commit -m "This will never work"

$ git commit -m "This might fix that thing"

$ git commit -m "I'm not very sure what I've done here"

$ git commit -m "Abandon hope all ye who enter here"

$ git commit -m "Ahhhh! Undo last undo."

$ git commit -m "Undo past mistakes"

$ git commit -m "All of the bugs have been changed"

$ git commit -m "Im probably going to regret this one in the morning .."

$ git commit -m "Become a developer they said, it will be fun they said…"

$ git commit -m "Fixed the previously fixed fix that was already fixed"

$ git commit -m "Wear short trousers"

$ git commit -m "Don't ask me why, just merge it"

$ git commit -m "Not sure why but it foxes things"

$ git commit -m "Grabbing the plunger"

$ git commit -m "mistakes were made"

$ git commit -m "Probably works, maybe not, only the Calendar/Date gods know"

$ git commit -m "Have to leave this bug in because customers actually expect this behavior"

$ git commit -m "I'm tired, I need you work already"

$ git commit -m "Fix it again again"

$ git commit -m "Commited from my iphone"

$ git commit -m "Making the sauce for the spaghetti code"

$ git commit -m "Let's wrap it up. It's weekend!"

$ git commit -m "thanks for your time"

$ git commit -m "if you're reading this, then something is broken and you're looking for someone to blame"

$ git commit -m "don't trust this commit"

$ git commit -m "Let there be change"

$ git commit -m "Unfortunately, it is successful"

$ git commit -m "Fire alarm went off, have to push quickly"

$ git commit -m "This is why you don’t do commits at 1am"

$ git commit -m "Un-oopsing the oops"

$ git commit -m "good luck debugging this"

$ git commit -m "This will be a problem with the year 2000, but I would not be there to see..."

$ git commit -m "They made me do that"

$ git commit -m "Adding comment for future self (next week, when I have forgotten)"

$ git commit -m "This'll do, I'm going to bed"

Show me another one! Tweet this commit message