SoftwareBY RabIT software engineering · April 14, 2020

Java has held a special place in the hearts of many developers since its release more than two decades ago, including our own. Since it is such a mature, widely-used technology, there are also plenty of great automated Java code review tools to choose from today.

According to last year’s Stack Overflow Developer Survey, it is still among the 5 most popular programming languages.

 

java code review tools - java popularity

Source: Stack Overflow

 

Also, according to the TIOBE index, Java is still the number one programming language today, just barely surpassing C. The index is calculated using the number of skilled engineers world-wide, courses and third party vendors, as well as queries in popular search engines such as Google, Bing, Yahoo!, Wikipedia, Amazon, YouTube and Baidu.

 

Briefly about code review & analysis:

Code reviews are processes where software developers and testers check if an already written source code complies with coding conventions and standards.

Apart from manual code reviews, static and dynamic code analysis can also be conducted with the help of automated tools.

Static code analysis tools examine the source code without executing it. Dynamic analysis is conducted while the code, or a part/unit of it (for example unit or integration testing) is being run.

 

Why are code reviews important?

Poor source code quality causes plenty of headaches, overworked days and sleepless nights for developers and product owners alike. Planning and conducting code reviews is often ignored by management, usually leading to long-lasting negative effects on development efficiency and even the whole business.

To briefly summarize, if the quality of the source code is left to deteriorate:

  • adding new features becomes increasingly difficult, while potentially breaking existing ones in the process
  • bug fixes take up more of the team’s time, missing deadlines and prolonging crucial updates
  • onboarding new developers requires more time if the code base is hard to read and understand
  • poor source code quality can also negatively impact users’ perception of the product, and the whole organization
  • future development estimations also become less accurate if it’s impossible to predict how long it takes to add new features without breaking existing ones.

For anyone who is interested in reading more about the effects of low-quality code, we’ve dedicated a whole article to this topic not long ago.

 

 

What is the basis of our recommendations?

Java has been our go-to technology for many custom software development projects over the last decade. It is, in fact, our most frequently-used programming language to date.

We’ve encountered many Java-based software projects throughout our work that were struggling to move forward because the source code had gotten so unstable that it was difficult, or straight-up impossible to develop further.

We were only able to stabilize these software products and continue feature development after running a whole assortment of tests and completing a ton of code refactoring work. The following recommendations are based on the experience gained throughout these projects.

 

 

We recommend using these Java code review tools:

 

Checkstyle is a static code analysis tool used in software development for checking if Java source code complies with coding rules. It basically automates the lengthy process of checking code and helps Java developers enforce coding standards.

It can find anything from class or method design problems to code layout and formatting issues. You can find the complete list of checks here.

Checkstyle has a large number of plug-ins as well that let teams integrate continuous code checks into their projects.

 

 

PMD or Programming Mistake Detector is an open source static source code analyzer that reports on issues found within application code.

The tool is used to detect common mistakes made in the code by using the standard rules or defining custom rule sets. Using PMD, teams can detect common flaws around naming conventions, unused variables and parameters, empty catch blocks, unnecessary object creation, etc.

PMD has plugins for JDeveloper, Eclipse, jEdit, JBuilder, Maven, Ant, Gradle, Jenkins, SonarQube and many other tools and IDEs.

PMD also contains CPD (or the Copy/Paste Detector), which is used to detect duplicate code in. We find this to be a very useful add-on, as duplicate code can be quite hard to find, especially in a large project.

Eliminating duplicated blocks of code is important for a number of reasons, like removing unnecessary grunt work during refactoring. It puts a lot of pressure on the developer to remember where they are located and edit them when making significant changes on the code base.

Also, if they are working in a team, developers otherwise have no way of knowing where other team members inserted duplicate code segments. This can make future development and maintenance tasks much more complicated.

Apart from Java, it can also be used for C, C++, PHP, Python, JavaScript as well as other programming languages.

 

 

Subscribe to the RabIT Newsletter

What you get if you join our email list:

  • Actionable insights about software development topics
  • Interesting case studies and news about IT innovation
  • No marketing spam

You can unsubscribe at any time

 

 

SonarQube is an open-source code quality inspection platform. It is used to perform automatic reviews with static analysis of code to detect bugs, coding errors, and security vulnerabilities.

The platform offers reports on duplicate code blocks, coding standards, unit tests, code coverage, code complexity, comments, bugs, etc.

It is a popular choice for analyzing Java code, especially for teams using Maven and Gradle, but others can also use it by manually providing bytecode to the analysis.

SonarQube currently supports a total of 27 programming languages including Java, C#, PHP, JavaScript, TypeScript, C/C++, Ruby, Kotlin, Go and Python for example.

 

JArchitect is a static analysis tool specifically meant for Java code. It supports a large number of code metrics like number of parameters, variables and lines of code, cyclomatic complexity, afferent and efferent coupling and so forth.

JArchitect also allows teams to expose architectural flaws, visualize and manage dependencies using directed graphs and a dependency matrix. This is only a few of the many useful features the platform can provide.

 

JUnit is a unit testing framework for the Java programming language. For reference, unit testing is a method for evaluating the performance of individual units, components or modules of the source code.

The framework allows teams to write and run unit tests for Java 8 and above. Its latest version, JUnit 5 is composed of several different modules:

  • The JUnit Platform – responsible for launching testing frameworks on the JVM.
  • JUnit Jupiter – a module that includes new programming and extension models for writing tests.
  • JUnit Vintage – which supports running JUnit 3 and JUnit 4 tests on the platform.

JUnit is the most popular unit testing framework for Java development projects, and is often listed among the most commonly included external libraries in general.

 

JaCoCo is an open-source toolkit for Java, used for measuring and reporting code coverage.

The term ‘code coverage’ is used in software development to define how much of a program’s source code is covered by a testing plan.

We are including this as sort of an honorable mention, as some other tools, IDEs and platforms already include JaCoCo as a plug-in. A few examples of these are:

  • SonarQube
  • Eclipse
  • Jenkins
  • Netbeans
  • IntelliJ
  • Gradle
  • Visual Studio

 

 

Summary

 

Of course, these recommendations are purely based on our own experience and preferences.

Which Java code review tools you’ll choose for your own development projects should be based on a fair amount of testing and their compatibility with your technology stack of choice.

If at any point you find yourself in need of another set of eyes during code reviews, don’t hesitate to reach out to us with your questions.

Thanks for reading our article!

 

java code review cta

RabIT software engineering

RabIT is an innovative software engineering company from Hungary. Our goal is to help startups and enterprises drive growth through technology innovation and make a real impact in their industries.

Code quality and transparency are our main priorities throughout each project.

SoftwareBY RabIT software engineering · April 06, 2020

Significant advancements in cloud technology and automation over the past decade have led to the rise of new, disruptive outsourcing solutions. Remote personnel can now be more closely integrated into a company’s everyday work processes. Compared to traditional IT outsourcing, hiring a dedicated software development team is seen as more like a strategic partnership.

Apart from providing staff augmentation services, these teams also actively participate in making critical product-related decisions. Working with a dedicated software development team can feel like having your own remote IT department, with the added flexibility of an on-demand service.

However, reaching this level of efficiency requires careful planning, effective management and a lot of optimization.

The goal of this article is to guide you in building a high-functioning dedicated software development team and identifying ways to improve their efficiency.

 

Why should you consider hiring a dedicated software development team?

While cost optimization remains one of the main reasons for outsourcing, it’s no longer number one. Today, most businesses primarily hire dedicated software development teams to gain access to technical skills that are not available in-house.

When executed well, this can also provide competitive advantage by improving organizational operations, making them more agile, efficient and effective.

Other benefits of hiring dedicated teams are:

  • Faster, more cost-effective hiring process
  • Improves flexibility in use of resources – they can be scaled up or down quickly
  • Allows management to focus more on core business processes

 

1. THE SELECTION PROCESS

Of course, at the core of every development project there is the product itself. Before starting the search for a dedicated software development team, you must already have a clear, well-defined product vision.

Here we’re referring mostly market-related questions. You must define who the intended users are, what the software should do and for which platforms (and devices) you want to develop it.

One of the greatest benefits of working with a dedicated team is that they can contribute to the project from the early planning stages, well before the actual development work begins. They can help you make key technical decisions related to software architecture, features and user stories, and then plan the development process accordingly. This is especially useful if you don’t have any in-house technical expertise.

When selecting your dedicated software development team, keep in mind that you aren’t simply looking for a service provider, but rather a strategic partner. Apart from having the necessary technical skills and experience, they must communicate exceptionally well, and be open to work with you in a completely transparent manner.

This means giving you full insight into their processes and a clear understanding of the ongoing work at all times. Without this, you wouldn’t be able to keep control over the project, and it could easily lose direction over the long term.

 

Subscribe to the RabIT Newsletter

What you get if you join our email list:

  • Actionable insights about software development topics
  • Interesting case studies and news about IT innovation
  • No marketing spam

You can unsubscribe at any time

 

When making a decision, collect all relevant information such as team size, composition and seniority, technical knowledge, project history etc., from at least 3-5 vendors. When this is done, evaluate them based on the following criteria:

  • How they communicate – language skills, response time, detail and clarity of information.
  • Have they successfully completed projects with the same level of complexity?
  • Do they have developers with the required level of seniority and technical knowledge?
  • Since we’re talking about long-term cooperation, do they also have a system for expanding their knowledge pool and incorporating new innovations?
  • Do they have effective project management quality assurance processes in place?
  • What did their previous clients say about them? Try to find third-party verified reviews from sites like Clutch.co, or ask if you can speak to any of their former clients directly.

 

2. DEVELOPMENT METHODOLOGY

There is no such thing as a perfect, one-size-fits all development methodology for all teams and all industries. The recommendations in this section are based on our own experience and preferences.

We usually recommend using an Agile methodology based on Scrum or Kanban. We prefer these as opposed to the traditional waterfall methodology because they allow us to include development partners much more closely into the development process. Thanks to regular meetings and product demonstrations, they are constantly able to provide feedback about the completed work, making sure that project stays on track.

Scrum is a project management framework that breaks up longer development processes into two-week periods (or sprints). After completing each sprint, the progress is demonstrated to the product owner, who can then give feedback and make adjustments to the project if necessary.

Close communication and constant inclusion of the client makes the project much more likely to stay on course and deliver positive results.

 

dedicated project manager scrum board

Scrum board example

 

Unlike Scrum, the Kanban approach is not iterative, so it allows the software to be developed in one large development cycle. This cycle has no predefined end point. The software requirements get broken up into smaller work items, which then enter the development process in a prioritized order.

A work item is not allowed to move on to the next phase until some capacity opens up ahead. This approach is more useful if fixed timeframes aren’t sustainable for the project.

 

dedicated project manager kanban board

Kanban board example

 

As I mentioned at the beginning of this section, there is no such thing as a one-size-fits-all methodology. Copy-pasting the Agile manifesto for your team won’t be an ideal solution.

This is why we only recommend it as an outline for your process. It will be up to you and your partner to optimize each aspect of the methodology to fit your organization and in-house team composition as much as possible.

What we do is optimize every aspect of the development process to the needs of each individual client. Everything from frequency and channels of communication, team size, composition, monthly work hours, issue tracking and reporting and much more can all be customized to fit unique organizational requirements. Because of its flexibility and iterative nature, this is called an Adaptive Agile methodology.

 

3. SETTING UP THE INFRASTRUCTURE

As we mentioned at the beginning of this article, recent innovations in cloud technology provided developers with some essential new tools for working together from different locations. There are many available solutions for communication, issue tracking and version control that can greatly improve development speed and efficiency.

Which tools your team uses will depend on specific project requirements and personal preferences as well. From our own experience, we recommend choosing from the following solutions:

1. Communication & presentations

  • Skype – For daily updates, group calls and live demos
  • Slack – Dedicated channels where development teams and the client can discuss project-related issues
  • Hangouts – Group video calls, video meetings
  • TeamViewer – Great for screen sharing during live demos

 

2. Issue tracking – tools for managing and maintaining a list of issues (or tasks). We use these to manage tasks during development sprints. We also give access to clients to help them oversee what’s happening with their project. Issue trackers are absolutely key to keeping the development process efficient.

  • Jira
  • Asana
  • Trello

 

3. Version control – tools that allow teams to track changes to a set of documents. They are an essential part of every software development project, where a team of people concurrently make changes to the same files over a long period of time.

  • GitHub – one of the world’s largest software development platforms that provides hosting for software version control using Git.
  • GitLab – popular web-based DevOps lifecycle tool that provides a Git-repository manager providing wiki, issue-tracking and CI/CD pipeline features.
  • BitBucket – also web-based version control repository hosting service for source code and development projects that use either Mercurial or Git revision control systems.

 

4. Other tools

  • Atlassian Confluence – an enterprise knowledge management system that is used to help teams prepare and share software documentation (setup guide, technical details, etc.) efficiently.
  • Jenkins – a CI/CD tool (Continuous Integration / Continuous Delivery) that helps automate building, testing, and deployment, to allow continuous integration and delivery during software development projects.

 

4. QUALITY ASSURANCE

Quality assurance plays a very crucial role in the process of software development. It saves money and time by spotting bugs and errors early in the software development life-cycle.

Software that is newly developed may have inconsistencies, redundancies, and flaws; therefore, we think that proper QA should be mandatory. Software testing ensures that the product a company is developing meets all requirements, truly provides value to end users and has a long lifespan.

When hiring a dedicated software development team, make sure they have quality assurance processes in place to perform at least the following types of tests:

  • Usability testing – Checking if end users will be able to easily use and understand the software. Helps identify usability issues and improve user experience.
  • Compatibility testing – Verifying that the software works perfectly on devices with various screen sizes, running different operating systems. In case of web applications, this includes testing cross-browser compatibility as well.
  • Functional testing – Checking whether the software works in accordance with feature specifications and business requirements.
  • Performance testing – Also known as load and stress testing. It means testing the robustness and stability of the software under extreme conditions.

We recommend that quality assurance should be done by at least one person on each team. Before committing new features, their functionality and effect on already existing features should be thoroughly tested in a safe environment.

If done properly, this will greatly improve software quality throughout the software’s entire life cycle.

 

dedicated software development team composition

Example of our own dedicated software development team composition

 

5. CODE REVIEWS

Code review is also a kind of quality assurance activity, where a software developer checks an already written source code for errors and bugs. Apart from manual code reviews, there are also a lot of automated tools available for static and dynamic code analysis.

We also consider code reviews to be an essential part of every development project. The work of each developer on the team should be reviewed by a senior colleague. This is especially important for junior developers, but everyone else’s work should also be reviewed by at least one other expert.

Here are some commonly used code review methods:

  • Over-the-shoulder reviews – When the author writes a code and simply calls the reviewer over to have a look at it.
  • Pair-programming – Two developers write code together at the same workstation.
  • Tool-assisted code review – Reviewers and authors use specialized tools designed for code review. The tools are used for collecting metrics, transmitting and displaying files, commentary, collecting files etc.
  • Email pass-around reviews – Most open-source projects used to prefer this form of code review. Here, the author emails complete files to reviewers. Reviewers then examine the files and suggest changes. It is rarely used today, mainly as an alternative if tool-assisted code review isn’t an option.

In our own development processes, every line of code must pass peer review before being committed. This might seem like a lot of extra work beforehand, but it actually saves clients a considerable amount of time and money in the long run. If the code is clean and low on errors, new features can be developed much faster. It also decreases time is spent on fixing errors later, because most of them were already discovered during reviews.

Throughout our work we’ve encountered many software projects that were struggling to move forward because the code base had gotten so unstable that it was difficult, or straight up impossible to develop further. In a few cases, more than 12 months worth of development investment would have resulted in an unusable product without intervention.

You can read about our approach to code reviews in much more detail in our earlier article:
Why Source Code Quality Is Crucial in Software Product Development

 

TO SUMMARIZE

As opposed to traditional outsourcing, dedicated software development teams can serve as integrated product development partners. If managed properly, they can work closely with you to deliver top-notch digital products while also helping to make your entire organization more agile, flexible and efficient.

From selecting a qualified team, all the way to managing development and quality assurance processes, they should be seen as a strategic partner, instead of simply as a service provider.

Your management team must work together with them to optimize work processes, just like they would with an internal IT department. This should include everything from development and project management methodologies, all the quality assurance and code reviews.

Building an effective cooperation with a capable dedicated software development team can provide ways for your organization to constantly innovate and gain a competitive edge while also reaping the benefits of traditional outsourcing.

RabIT software engineering

RabIT is an innovative software engineering company from Hungary. Our goal is to help startups and enterprises drive growth through technology innovation and make a real impact in their industries.

Code quality and transparency are our main priorities throughout each project.

SoftwareBY RabIT software engineering · March 30, 2020

With the rapidly growing popularity of digital entrepreneurship and business process digitization, demand for software products is at an all time high.

Due to the accelerating demand, global competition, as well as other factors like the increased use of outsourcing, low development costs and faster time-to-market are quickly becoming top priorities over product quality.

 

“Why should I care?” you might ask.

If you are planning to, or already in the process of developing a software product, ignoring the quality side of the process can easily lead to wasting the entire development budget and severely hurting your business.

Throughout our work we’ve encountered many software projects that were struggling to move forward because the code base had gotten so unstable that it was difficult, or straight up impossible to develop further. In a few cases, more than 12 months worth of development investment would have resulted in an unusable product without intervention.

 

The goal of this article is to highlight the importance of maintaining high source code quality throughout the software product life cycle. We will talk about the possible effects of low-quality code on your project (and entire business) and list effective ways to ensure high product quality.

 

 

What does high source code quality mean?

To avoid being vague, first let us try to elaborate on what we mean by high source code quality.

High quality code means that your source code must perform well with regard to the following:

  • Optimization – The code is written in an optimized structure, meaning that it’s not overly complicated and convoluted.
  • Readability – The source code is easy to follow, standards of indentation and formatting are met, so that the code and its structure are clearly visible.
  • Maintainability – Signifies the efficiency by which the code base can be understood, repaired, or enhanced.
  • Compatibility – The software’s ability to properly run on all intended devices and operating systems.
  • Security – The code base is continuously being checked for vulnerabilities like malicious code that can be discovered and exploited by outside parties.
  • Understandability – The code is easy to understand for new developers in the future for increased time-efficiency.
  • Documentation – All-inclusive and up-to-date source code documentation is written throughout the project.

 

 

What does low-quality code look like?

Now that we’ve established what high source code quality actually means, you probably have an idea about what poor code looks like. If a code base is lacking in the qualities listed above, it is considered low quality.

To be more specific, low-quality source code:

  • is written in an unnecessarily complicated structure,
  • is difficult to read and understand for developers,
  • is difficult (and expensive) to maintain and develop further,
  • has compatibility issues with different devices and operating systems,
  • has easily exploitable vulnerabilities,
  • is poorly documented.

 

In our opinion, it’s a bad idea to wait to check the quality of your product’s source code before live release. By that point, fixing these issues becomes much more expensive and time-consuming than it should be.

This is why source code should be written following high quality standards in the first place. We talk about ways to achieve this in the sections below.

 

How does poor source code quality affect a project or business?

Technical debt is “a concept in software development that reflects the implied cost of additional rework caused by choosing an easy (limited) solution now instead of using a better approach that would take longer.”

It’s pretty much the software development term for sweeping issues under the rug that you’ll have to deal with later. Constantly choosing the easy way out has real consequences for long-term projects. Too much technical debt can eventually cripple the development process entirely.

Technical debt has to be “paid” sooner or later. Even if you change development teams mid-way, the new team will have to deal with the extra work left behind by their predecessors.

Simply ignoring mandatory periodical maintenance and refactoring tasks also creates a lot of technical debt during long projects.

 

technical debt source code quality

Dilbert by Scott Adams

 

The symptoms of low-quality code only start to appear in later project stages, by the time software features are getting more complex. This only makes them more dangerous.

If developers don’t review the source code frequently, by the time they notice something’s wrong, it’s usually too late. Development tasks start to take longer to complete, bug fixes take up more and more of the team’s time, missing deadlines and prolonging crucial updates.

Spaghetti code causes even more headache if there is a decent amount of fluctuation in your development team. New developers will have trouble understanding the code base and it will take weeks until they can effectively contribute to developing it further.

Poor code quality also makes it impossible to predict how long it takes to add new elements without breaking others. This causes future development estimations to become highly inaccurate as well.

 

From a business perspective, software product development is an investment from which you expect a return – so just like any other. This return can come in the form of revenues if we’re talking about an SaaS solution, or cost savings and increased efficiency if we’re talking about software for internal, organizational use.

However, with a low-quality product that doesn’t sell, or effectively improve internal processes, your chances for a return drop significantly. In more severe cases, if the final product doesn’t reach live release at all, the development project can be considered a complete loss. This can mean multiple tens or hundreds of thousands of dollars worth of pointless spending, which can be crippling for most businesses.

If you can’t maintain an acceptable level of code quality, the “best case” scenario is that you’ll eventually get a working product, but at a much higher total investment cost.

Poor source code quality can also negatively impact customers’ perception of your product, and the whole organization. If a new release receives overly negative reviews from early users, it will take a lot of time and effort to win them over. While experience shows this isn’t impossible, it’s still better to prevent a fire from starting than having to put it out!

 

How can you ensure high code quality?

If you don’t have the necessary technical knowledge, it will be difficult for you to assess code quality without help from the development team. You’ll most likely only notice client-side issues related to speed, device compatibility and others directly affecting the user experience.

A good practice is to ask for frequent reports from the development team (sprint reports, release reports, etc.). These reports must contain the key project and code quality indicators. If you don’t have a technical background, ask the team to explain these indicators as many times as necessary.

If you still need help evaluating them, you can hire a third-party consultant who could even check the source code if necessary. If this is not an option, however, the development team must introduce their own quality assurance and code review processes for quality management.

 

Quality assurance

Quality assurance, or QA should be an essential part of the software development life cycle. Its goal is to validate the quality and functionality of the software before release, and make sure that the final product provides the best possible user experience.

Note: QA focuses on testing the quality and functionality of new product versions, not the source code directly.

However, quality assurance still plays an important role in detecting bugs and errors in the software before it gets released.

 

Here are a few widely-used types of quality assurance:

  • Usability testing – Checking if end users will be able to easily use and understand the software. Helps identify usability issues and improve user experience.
  • Compatibility testing – Verify that the software works perfectly on devices with various screen sizes, running different operating systems. In case of web applications, this includes testing cross-browser compatibility as well.
  • Functional testing – Checking whether the software works in accordance with feature specifications and business requirements.
  • Performance testing – Also known as load and stress testing. It means testing the robustness and stability of the software under extreme conditions.
  • Security testing – Systematically checking the software for exploitable vulnerabilities. Today there’s a whole separate field in IT specializing in security testing called Ethical Hacking.

 

Code review & analysis

Code review is also a kind of quality assurance activity, where a software developer checks if the written source code complies with coding conventions and style standards. It is also used to examine whether the best possible technical solution was used by the developers or not.

Apart from manual code reviews, there are also a lot of automated tools available for static and dynamic code analysis.

Code review is a process by which developers review each other’s source code. The two roles present in a peer code review are:

  • The author: the person responsible for developing the code being reviewed.
  • The reviewer: the person who is responsible for examining the code.

 

Some commonly used code review methods:

  • Over-the-shoulder reviews – When the author writes a code and simply calls the reviewer over to have a look at it.
  • Pair-programming – Two developers write code together at the same workstation.
  • Tool-assisted code review – Reviewers and authors use specialized tools designed for code review. The tools are used for collecting metrics, transmitting and displaying files, commentary, collecting files etc.
  • Email pass-around reviews – Most open-source projects used to prefer this form of code review. Here, the author emails complete files to reviewers. Reviewers then examine the files and suggest changes. It is rarely used today, mainly as an alternative if tool-assisted code review isn’t an option.

 

Apart from improved source code quality, code reviews also make it easier to train new development team members. In the long run, they lead to the team having a more consistent coding style overall, improving the whole development process as well.

For both larger and smaller code bases, your team will likely have to use automated code analysis tools as well. The difference between static and dynamic code analysis is already in their names.

Static code analysis tools examine the source code without executing it. Dynamic analysis is conducted while the code, or a part/unit of it (for example unit or integration testing) is being run. Code analysis tools help developers save a huge amount of time on fixing errors by identifying them in a matter of seconds.

 

Our own team mainly uses these code analysis tools:

  • Checkstyle – a static code analysis tool used in software development for checking if Java source code complies with coding rules.
  • StyleCop – a static code analysis tool from Microsoft that checks C# code for conformance to StyleCop’s recommended coding styles and a subset of Microsoft’s .NET Framework Design Guidelines.
  • PMD – or Programming Mistake Detector is an open source static source code analyzer that reports on issues found within application code.
  • CPD – or Copy/Paste Detector is PMD’s duplicate code detection for (e.g.) Java, JSP, C, C++, ColdFusion, PHP and JavaScript code.
  • ESLint – a static code analysis tool for identifying problematic patterns found in JavaScript code.
  • TSlint – static analysis tool that checks TypeScript code for readability, maintainability, and functionality errors.
  • ReSharper – a group of products that provides a series of features for Visual Studio developers including code analysis, refactoring, navigation, test runner, build runner, etc.
  • JUnit – a unit testing framework for Java often used in test-driven development
  • JaCoCo – an open-source toolkit for measuring and reporting Java code coverage.

For version control:

  • GitHub – one of the world’s largest software development platforms that provides hosting for software version control using Git.
  • GitLab – a web-based DevOps lifecycle tool that provides a Git-repository manager providing wiki, issue-tracking and CI/CD pipeline features.
  • Bitbucket – also web-based version control repository hosting service for source code and development projects that use either Mercurial or Git revision control systems.

 

So what should the development methodology look like?

There is no such thing as a perfect, one-size-fits all development methodology for all teams and all industries. The recommendations in this section are based on our own experience and preferences.

Note: While the main topic of this article is code quality, these development methodologies also focus on assuring the overall quality of the finished product.

We recommend using an Agile methodology based on Scrum or Kanban. Scrum in particular can be very beneficial for product owners to keep a close eye on the project’s progress. Frequent communication and product demos allow you to have a good overview of the newly completed features and even test them yourself.

This methodology also helps your team break down large and complex projects into smaller, more manageable chunks called sprints. These are 2 weeks long by default, and they contain a previously agreed-upon set of user stories and development tasks.

 

dedicated project manager scrum board

Scrum board example

 

As for team composition, QA experts and senior code reviewers should be integral parts of both small and larger teams. We also recommend to regularly include less experienced developers as code reviewers for training purposes. In these cases they must still be assisted by a senior colleague.

If you have to coordinate the work of multiple parties, a dedicated project manager can also be a valuable addition to the crew.

Here is an example of our own team’s composition for most projects:

 

As I mentioned at the beginning of this section, there is no such thing as a one-size-fits-all methodology. Copy-pasting the Agile manifesto for your team won’t be an ideal solution.

This is why we only recommend it as an outline for your process. It will be up to you and your team to optimize each aspect of the methodology to fit your organization and in-house team composition as much as possible.

We also do this sprint after sprint with our own clients, which is why we recommend it to others. For example, it might not make sense for a small team to hold daily stand-up meetings, if team members are working really closely together and they already know what everyone is working on at all times.

In these cases, it might be better to organize a single, longer weekly team meeting instead. It should also be examined whether sprint planning and retrospective meetings work effectively in their standard forms, or if they could be organized in a better way.

Most other aspects of this methodology can be optimized in similar ways as well.

 

To Summarize

While low code quality is rarely among the leading agenda during product management meetings, it is an increasingly important topic for businesses that rely on custom-built software to grow.

Apart from drastically increasing development costs and time – hurting profit margins -, low source code quality also negatively impacts customer satisfaction.

When it comes to software products, you only have a few seconds to form a positive first impression with users. If their first experience with your product is slow, clunky, or results in a crash or any kind of bad experience, you will need to invest a lot of time and effort to better their opinions.

Instead of having to put out the fires, prevent them by integrating coding standards, quality assurance and code review into your development process as early as possible. While it may just seem like extra work early on, it will most definitely save you a lot of headache and resources in the long run.

RabIT software engineering

RabIT is an innovative software engineering company from Hungary. Our goal is to help startups and enterprises drive growth through technology innovation and make a real impact in their industries.

Code quality and transparency are our main priorities throughout each project.

SoftwareBY RabIT software engineering · October 31, 2018

Code review is a process by which developers review each other’s source code. Peer code review not only makes a better code but also makes better teams.

The two roles present in a peer code review are –

  • The author: A person who is responsible for developing the code being reviewed.
  • The reviewer: He is the person who is responsible for examining the code.

 

Commonly used forms of peer code review

 

Over-the-shoulder code review

In this type of review, the author writes a code and calls the reviewer over to have a look at it.

Benefits

  • Easy to implement
  • Fast to finish

 

over the shoulder peer code review

 

Email pass-around reviews

Most open-source projects prefer this form of code review. Here, the author emails complete files to reviewers. Reviewers then examine the files and suggest changes.

Benefits

  • Works with remote software developers
  • Easy to implement
  • Easy to involve other people
  • Doesn’t disturb reviewers

 

Pair-programming (review)

In this form of code review, two developers write code together at the same workstation.

Benefits

  • Effective at promoting knowledge-transfer and spotting bugs.
  • The reviewer is very close to the code and can provide a detailed review.

 

Tool-assisted code review

Reviewers and authors use specialized tools designed for code review. The tools are used in all aspects of the peer code review: collecting metrics, transmitting and displaying files, commentary, collecting files etc.

Benefits

  • Automated file gathering
  • Workflow enforcement
  • Automated metrics collection

 

peer code review cta

 

Why do you need to devote time for code reviews?


HIGHER CODE QUALITY

While QA testing is absolutely essential to improve the performance of your final product, code reviews are just as important. Source code reviews guarantee a higher quality code base. Not only do they improve software performance, they also allow you to expand your product and add new features much more easily in the future.

Higher code quality also leads to less time spent in handling technical debt and resolving errors. Technical debt, also known as code debt, is the expense a software company pays out due to poor development processes within its existing codebase. These debts should be resolved as quickly as possible.

Codacy conducted research and found that software developers spend about 26% of their time working on technical debt and on fixing bugs. According to the same research, code reviews have the greatest impact on the quality of the code, followed by coding style and standards and testing.

 

REDUCED COSTS

The earlier a bug is spotted the less it will cost to resolve it. Discovering and resolving errors at the early stage of development is relatively less costly as compared to the expensive process of bug fixing happening at the advanced stages of software development. An external reviewer can quickly and easily spot mistakes made by software developers.

 

IMPROVED DEVELOPMENT PROCESS

In addition to fixing bugs and improving software quality, code review improves your software development processes and the team as a whole.

 

Subscribe to the RabIT Newsletter

What you get if you join our email list:

  • Actionable insights about software development topics
  • Interesting case studies and news about IT innovation
  • No marketing spam

You can unsubscribe at any time

 

TRAINING NEW, LESS EXPERIENCED DEVELOPERS

Code review helps development teams train new developers and familiarize co-workers with other modules. The process of code review encourages the sharing of ideas across the team and provides an opportunity for new developers to acquire skills and improve their code’s performance. These younger developers also get an opportunity to sharpen their skills and become experts in their field. The reviewers also get to learn new ideas and techniques from the code they are reviewing.

 

BETTER ESTIMATES

Code review helps in sharing of knowledge between the reviewer and the author. The reviewer is quite familiar with the known issues in the code base and the complexity of the project. Therefore, the development team members get to know the product in detail and the software developers learn to make better estimates of the future work from the reviewer.

 

CONSISTENT CODING STYLE

Code review enforces a consistent coding style throughout a software project. This makes the code readable by developers who might have joined the project at any given time during software development.

While this might seem like a trivial matter, you can save a ton of time and resources on the long run if the source code is easy to read. This is especially crucial if we are talking about a huge code base.

peer code review coding styles

To Summarize

Peer code review should be an integral part of every software development process. Apart from fishing out errors in time, your team will also learn to work together more effectively. Less experienced developers can also learn a lot from their senior colleagues during this process.

Choosing which method you’ll use depends on your preferences and team setup. The important thing is to start implementing reviews into the development process as soon as possible.

If you would like to learn more, read about our team’s approach to conducting code reviews.

In here we talk about our process, what tools we use and what are the most crucial aspects during reviews.

RabIT software engineering

RabIT is an innovative software engineering company from Hungary. Our goal is to help startups and enterprises drive growth through technology innovation and make a real impact in their industries.

Code quality and transparency are our main priorities throughout each project.

IT ProcessBY RabIT software engineering · February 26, 2018

If you have already read some articles on the subject, you have probably come across the line by now, which says that about 1 out of 3 offshore software product development projects fail.

We have already gone through some of the more common reasons why most offshore software projects never see the light of day in one of our earlier articles.

In this article we will tell the story of how we helped revive some of these projects through our work at RabIT software engineering.

Here are some real life examples of an offshore software development project turning south. Of course, we won’t be mentioning any names here, as the only purpose of this section is to point out that most failing software projects can be salvaged, even if things are looking very very ugly.

Case 1 – The spaghetti code that made no sense

offshore software

 

About two years ago, a client approached us looking for an experienced software developer to join their existing offshore software development team. They were building a new online marketing tool that will make the client’s everyday work much easier. He is also planning to release it as a globally available SaaS solution later this year.

Our new client knew that something was very, very off about the code written so far, but he couldn’t quite put his finger on it, having no background in software engineering himself. So he basically hired us to have a look at the project and try to get it back on track if possible.

Our own CEO joined the client’s team of three other developers from the Philippines. We started by looking at the source code and running some good old tests on it. To put it lightly, it was a complete mess. Imagine a special kind of spaghetti code that was full of anti patterns, inefficient and illogical solutions, and was generally in very bad shape.

So we had our work cut out for us. The initial goal was just to clean up the previously written code, which was no easy feat itself. To test the current state of the source code we used code analysis tools like Checkstyle, CPD, PMD and JSHint. Checkstyle identified about 60.000 errors during our initial testing phase. We collected the necessary metrics, then got to work right away. It was essential to start with code refactoring, because at this stage the code was so unreliable, that it was impossible to continue development work efficiently.

Several weeks and a lot of code cleanup later, 60.000 Checkstyle warnings turned into 1.500, which was low enough to allow for more efficient software development work. We also managed to solve some functionality issues that the previous team claimed to be unsolvable. As things started to fall into place, we could gradually focus more on developing new features, instead of code refactoring.

In the meantime, the initial development team was let go, and we took over the project entirely. This was never our intent, we work together with other outsourcing teams on a regular basis. The client made this decision after the other team continuously failed to meet our software development quality standards.

We are currently focusing on eliminating the remaining coding errors, while constantly implementing new features and design elements to the application. Despite the early setback, our client still expects us to deliver a top-quality finished product that is highly competitive on today’s market, and that is exactly what we aim to do.

Case 2 – When things go from bad to worse

offshore software

 

A couple of months ago we were approached by two sport-loving entrepreneurs. They had a unique idea for a mobile application which is completely new to the market and does not have any competition as of yet. A small offshore software product development team from Russia had already started development by the time we joined the project.

The clients started looking for a senior software engineer because they were not satisfied with the work of the current developers. The Russian team claimed that some of the requested functions were impossible to develop, progress was made very slowly and the resulting code was unstable and unreliable. They needed someone who could see through the development process and had experience in leading a team of developers.

We started by running the usual tests on the source code, and the metrics were terrible. It was difficult even to get the application to run at that point. Three of our developers ended up joining the other team, with the support of a quality assurance tester and a project coordinator. Not much later, four freelance developers from India also joined the team.

 

Subscribe to the RabIT Newsletter

What you get if you join our email list:

  • Actionable insights about software development topics
  • Interesting case studies and news about IT innovation
  • No marketing spam

You can unsubscribe at any time

 

Our resposibilities included project leadership, software architecture design, team coordination and software development. We were tasked with managing the work of the Indian team as well. Because we were ready to take over the entire development process, the services of the Russian team were no longer required.

During this period, we were still making a serious effort just to correct source code errors, but we finally started to make some progress. Problems soon started to resurface when the Indian team kept falling behind on their development tasks. They refused to follow the coding standards, and when we tried to enforce them, they were always one or two weeks late on delivery. Their code simply couldn’t pass code review, and this lead to serious delays in development.

Our expectations weren’t unrealistic. We followed Google coding standards (to which we also added a few rules that we found important), and all parties unanimously agreed on the coding guide during our initial meetings. However, several weeks later, the Indian team also resigned from the project. We became fully in charge of full stack mobile app and server-side development.

By today we have reduced static code errors from 30.000 to 800. Some serious deviations from coding standards and illogical solutions also ended up forming bottlenecks in the program, which we have since removed. We are currently aiming to focus more and more on developing new app features and less on code refactoring. If all goes according to plan, a live version will be ready to launch in September.

Case 3 – When code quality is not the problem
offshore software
Startup Stock Photos

 

Of course, code quality isn’t the sole reason why offshore software product development projects end up failing. We have just recently taken over one of our newer projects from another Hungarian development agency, simply because they were failing to meet their promised deadlines. This development team was almost one year late on delivery when the client finally decided to replace them with another agency.

The product is an E-commerce website with integrated stock management, invoicing and delivery management. The end result will be a highly customized software solution with multiple features that are completely new on the market. This time around the code was beautifully written, and the former lead developer was very helpful and cooperative. It turned out that they had some serious internal management issues that eventually also led to the agency going out of business.

After some minimal adjustments to the source code, we could immediately start focusing on function development here. We are currently testing the final product together with our client, and it is set to go live in the very near future.

Summary

We have encountered more than 20 cases like these since we started in 2011.

Developing a unique custom software solution can be a risky endeavor. After reading stories like these, it is easy to understand why many business owners decide to stay far away from offshore software product development. However, by taking the necessary precautions during the selection process, outsourcing can become a reliable source of growth for your business in a small amount of time.

Remember, cost-efficiency is only one of the many benefits of offshore software product development. Hiring a highly competent and self-sufficient development team lets you focus on other areas of your business, and save a lot of time on recruitment and training, which also leads to a shorter time-to-market for your product.

If, while reading this article, you realized that you are in the same shoes as one of our clients was, or if you are just searching for a reliable software development team, don’t hesitate to reach out to us and tell us about your project at info@rabit.hu right away.

RabIT software engineering

RabIT is an innovative software engineering company from Hungary. Our goal is to help startups and enterprises drive growth through technology innovation and make a real impact in their industries.

Code quality and transparency are our main priorities throughout each project.