Have you ever wondered what separates a good programmer from a great one? It's not just about mastering the latest programming languages or frameworks. I recall a project where one developer's exceptional skills in clear communication and problem-solving turned a near-failure into a resounding success. This story is not unique. In my experience, the truly great programmers exhibit a set of skills and characteristics that go beyond the code. These qualities, often overlooked, are what I've observed in the field and what we'll explore in this post.
1. Write good git commit messages
Git is the backbone of collaborative software development, and a great programmer understands the importance of clear and informative commit messages. Their Git comments are concise yet descriptive, providing valuable insights into the changes made. A well-documented commit history can make debugging and collaboration a breeze, saving time and reducing frustration.
Great: ✅
git commit -m "fix: Resolve issue with user login failing" \
-m "The problem stemmed from an incorrect validation check that was blocking user access" \
-m "Closes #123"
Not like this: ❌
git commit -m "Fixed some stuff"
2. Comment their code well
In addition to Git comments, great programmers take the time to comment their code. While the code should be self-explanatory, comments provide context and explanations for complex logic or unusual decisions. It's a sign of consideration for their team members and future maintainers of the codebase. The comments are concise and to the point, avoiding unnecessary details or irrelevant information.
Great: ✅
// Hotfix for issue #123
// The problem stemmed from an incorrect validation check that was blocking user access
// Support backwards compatibility with old API until we can deprecate it
if (user.isValid()) {
console.log('😃')
}
Not like this: ❌
// Loops through the array
for (let i = 0; i < 10; i++) {
console.log('😒')
}
3. Understand conventions
Great programmers adhere to established coding conventions and standards. They understand the importance of consistency in a codebase, making it easier for the entire team to read, maintain, and extend the code. By following conventions, they demonstrate their commitment to writing maintainable and high-quality code.
// Snake case Java variable names are the best
// Cause I don't like camel case
// Same line curly braces are for losers
public class WarningCodeGore
{
public static void main(String[] args)
{
int my_variable_name = 42;
String another_variable_name = "Hello, World";
if (my_variable_name > 0)
System.out.println(another_variable_name);
else
System.out.println("Negative value");
}
}
4. Good at Naming
The age-old saying, "There are only two hard things in computer science: cache invalidation and naming things," holds true. Great programmers excel at naming variables, functions, and classes, making their code highly readable and self-explanatory. They take the time to choose meaningful and intuitive names, reducing confusion and cognitive overhead.
Good: ✅
const userOnboarded = user.firstName && user.lastName && user.email && user.phone;
if (userOnboarded) {
console.log('😃')
}
Not like this: ❌
const x = user.firstName && user.lastName && user.email && user.phone;
if (x) {
console.log('😒')
}
5. Does Not Blame Tools
A great programmer does not blame their tools when facing challenges. Instead, they adapt and find solutions. Whether it's an IDE, a version control system, or any other development tool, they use it to its full potential and overcome limitations without resorting to excuses.
"PHP is the root of all my problems" - Bad Programmer
6. Writes Readable Code Instead of Performance
While performance is essential in software development, great programmers learn prioritize readability over premature optimization. They understand that optimizing code before it's necessary can lead to complexity and reduced maintainability. They focus on writing clean, maintainable code first and optimize only when performance issues arise.
All in one line to saves space and it's faster: ❌
const accessLevel = role === 'admin' ? 'Full Access' : hasCompletedTraining ? 'Limited Access' : 'No Access';
Readable and maintainable: ✅
if (role === 'admin') {
accessLevel = 'Full Access';
} else if (hasCompletedTraining) {
accessLevel = 'Limited Access';
} else {
accessLevel = 'No Access';
}
Remember that there's no need to write fancy or flashy code. Keeping your code simple and readable, is often the best approach for maintainability and collaboration.
Any fool can write code that a computer can understand. Good programmers write code that humans can understand. - Martin Fowler
7. Writes Elegant Code that is Understood
Elegance in code is not about complexity but simplicity. Great programmers aim for elegant solutions that are easy to understand. They favor straightforward approaches and avoid overly clever or convoluted code.
In the context of code elegance, knowing when to use built-in functions or methods provided by the language can significantly impact the clarity and readability of your code. The examples below demonstrate this concept:
const hasEvenNumber = numbers.some((number) => number % 2 === 0);
let hasEvenNumber = false;
for (const number of numbers) {
if (number % 2 === 0) {
hasEvenNumber = true;
break; // Exit the loop once an even number is found
}
}
8. Writes Vertical Code
Writing vertical code means focusing on one piece of functionality at a time, keeping the codebase clean and organized. It is noticeable when someone does it. Great programmers understand that breaking down complex problems into manageable pieces results in maintainable code and efficient collaboration.
The choice between 80 and 100 characters per line often depends on the coding standards of your team or the conventions of the programming language or community you are working in. The idea behind line length limits is to ensure that your code remains readable and doesn't require excessive horizontal scrolling, especially when reviewing code on different devices or in different environments.
9. Writes documentation
Documentation is often an afterthought, but great programmers recognize its value. They create and maintain documentation that helps others understand the codebase, API, or project architecture. Well-documented code is a sign of professionalism and a commitment to making the development process smoother for everyone involved.
/**
* @api {get} /user/:id Get User Information
* @apiName GetUser
* @apiGroup User
*
* @apiParam {Number} id User's unique ID.
*
* @apiSuccess {String} name User's name.
* @apiSuccess {String} email User's email.
* @apiSuccess {Number} age User's age.
*
* @apiSuccessExample Success-Response:
* HTTP/1.1 200 OK
* {
* "name": "John Doe",
* "email": "john.doe@example.com",
* "age": 30
* }
*
* @apiError UserNotFound The specified user ID was not found.
*
* @apiErrorExample Error-Response:
* HTTP/1.1 404 Not Found
* {
* "error": "UserNotFound",
* "message": "User with ID 123 not found."
* }
*/
10. Comfortable with Bad Code and Technical Debt:
In the real world of software development, bad code and technical debt are inevitable. Great programmers are not discouraged by encountering less-than-ideal code; instead, they approach it with pragmatism and understanding. They recognize that bad code and technical debt often arise due to time constraints, changing requirements, or other factors beyond their control. They can distinguish between necessary short-term compromises and long-term code quality and know how to manage technical debt effectively.
11. Takes Technical Debt Responsibly
Great programmers are not afraid to acknowledge technical debt. They understand that shortcuts taken today may lead to problems tomorrow. When they do take shortcuts or make compromises, they document them and prioritize addressing technical debt as part of the development process.
function calculateInvoiceTotal(items) {
// TODO: Refactor this function to improve performance
// and handle edge cases more gracefully.
let total = 0;
for (let item of items) {
total += item.price;
}
return total;
}
12. They Are Respectful
Perhaps the most critical quality of a great programmer is their respect for others. They respect their team members, stakeholders, and the users of their software. This respect is evident in their communication, collaboration, and approach to problem-solving. They listen actively, give credit where it's due, and remain open to different ideas and perspectives.
Great programmers create a positive and inclusive working environment, where everyone's input is valued, and constructive feedback is encouraged. They understand that software development is a collaborative effort, and respectful interactions are essential for a cohesive and productive team. They do not look down on those below them or dismiss the ideas and opinions of others. Instead, they uplift and empower their colleagues, recognizing that each person brings unique insights and skills to the table. This atmosphere of respect and inclusion not only enhances team morale but also results in better software solutions that meet the needs and expectations of all stakeholders.
Conclusion
In conclusion, the journey to becoming a great programmer extends far beyond technical prowess. It's about cultivating a blend of technical skills and personal qualities like clear communication, respect for others, and a keen sense of responsibility. As we navigate the complexities of software development, let's strive to embody these traits. I encourage you to reflect on your own practices. Are there areas you excel in, or perhaps aspects you could improve? Embracing these qualities not only makes us better developers but also enhances our teams and the projects we contribute to.
