A good developer is someone who works intelligently, knowing the ins and outs of their job, but also someone who is a good collaborator and is completely reliable.
Developers need to be cheerfully flexible as they work to make scalable solutions in their software. Code needs to be efficient and up to the task of sustaining testing and updating.
Writes long-term useful and long-term maintainable code.
Matter is based on an ontology of over
30 recommended skills.
Born in 1815, Lovelace is considered one of the very first computer programmers. Always interested in the sciences, Lovelace was immediately taken with Charles Babbage’s Analytical Engine. She was the first person to make the leap of thought that computers could do more than crunch numbers, but could manipulate symbols. Her notes include what is considered to be the very first algorithm designed for machine processing. To do this at any era would be groundbreaking, but Lovelace did it during Victorian England when few women were in the sciences.
A professor at MIT where she leads the Programming Methodology Group, Liskov was one of the first women in the United States to be granted a doctorate in computer science (in 1968), and is a Turing Award winner. Among her accomplishments is the eponymous Liskov substitution principle (a principle relating to subtyping in computer programs), creation of the Venus operating system, and the design and implementation of CLU, a coding language that led to the development of object-oriented programming.
Founder of both Trello and Stack Overflow, Spolsky created The Joel Test, a list of twelve yes-or-no questions that can be answered to determine the quality of a software team. These rules include things like “Do you use source control?” and “Can you make a build in one step?” He contends that the very top companies score a 12, while most software organizations are scuttling around near 2 or 3, and they’re in need of serious help.
It’s next to impossible to find a software product that was created entirely by one person. Collaboration is about communication and supportiveness in creating maintainable and readable code bases.
A developer should be writing consistent and efficient code, and doing so in a reliable fashion. The code should support testability, and update easily without breaking.
Scaling is essential in writing good software. The end goal of a business is to grow, thus a software solution that is inflexible and unscalable is going to fail the test of time.
Good code should be code that can stand on its own without the constant care of the coder, surviving the test of time. Documentation is essential to making sure that you’re leaving your product in capable hands.
While there is the occasional need for pulling a late shift to get something done, you want to avoid burning out on sleepless nights and energy drinks.
A good developer isn’t one who sets up a fiefdom that no one else can navigate. Having secret backdoors and shortcuts that you hide from coworkers is a fast way to get taken off a project.
In an ideal world, code is self-explaining, but it’s often recommended to add comments to the code to explain its role and functions. It makes it much easier for anyone who didn’t take part in writing the code to understand and maintain it.
Efficiency is directly related to software performance and speed. Software quality can be evaluated with the efficiency of the source code. Nobody likes to use software which takes a long time to perform an action.
Testability measures how well the software supports testing efforts. It relies on how well you can control, observe, isolate, and automate testing, among other factors. Testability can be measured based on how many test cases you need to find potential faults in the system. Size and complexity of the software can impact testability
Requirements change frequently. It could be that new customer feedback has resulted in new requirements outside of a project’s original scope. This is why it’s important to write code that is resistant to change. This is called extensibility. Extensible code will allow you to add or remove features quickly without introducing bugs.
Maintainability is about writing code in a way which is easy to add new features, modify existing features or fix issues with a minimum effort without the risk of affecting other related modules and functionalities.
Readability is the ability to write code that is easily, quickly and clearly understandable by someone new or someone that hasn’t viewed the code for some time. It is important to ensure that everybody can understand the code written by everyone else.
Reliability is the ability to perform the operations consistently without any failures, every time it runs. The software would be less useful if the code functions differently every time code runs even though the same input is given in the same environment.
Writing reusable code measures whether existing code can be used again. Code is more easily reused if it has characteristics such as modularity or loose coupling.
Writing robust code is the ability to cope up with the errors during the program execution in spite of unanticipated conditions. Typically software is fragile and can be buggy, but the error handling needs to be done gracefully. In order to achieve robustness, software has to be tested with common and uncommon conditions.
Code Quality shouldn’t be practiced in a vacuum. Improve your Code Quality by exploring and developing these complementary skills.