Several months ago, a few of your colleagues decided to join forces with
you as you had come up with a concept for an innovative web application,
shared the ideas with your friends and relatives, and began developing a
business plan. After a few months of performing some initial market
research, working on your pitch, and raising some initial funding, you
decided to bootstrap the project and start designing and developing the
product.
During your research phase, you came across several articles about this
exciting new technology called, Ruby on
Rails. You were impressed with many of the
sites that were being developed on this new framework as well as the
community that surrounded it. Your team decided that it would be a great
idea to follow this trend and use Rails as the platform for your new
product.
At this point, you began soliciting freelance developers and/or firms to
hire for the design and implementation of your project. Eventually, you
make a decision and break ground on building the product.
Let’s jump forward to the present day.
You’ve been in heavy development for quite some time. Your product has
gone through a series of design changes and you’ve recently begun to
allow other people to begin testing the application. You’re receiving a
lot of bug reports as people use the system. Your development team
quickly fixes them as they appear, but you’re noticing a trend in the
development process.
The speed of implementing new features is drastically slowing down as
your development team is spending most of their time fixing bugs. Along
with that, they are becoming frustrated by the project because they
can’t keep up with your new feature requests while trying to keep up
with your growing number of bug reports. You’re becoming concerned about
the stability of the product and are slightly suspicious that your
developer(s) might not be as good as they suggested they were.
Did you hire a bad development team? Chances are, you may not be able to
tell. You’re not a developer, so reviewing their code would almost be a
waste of time. How would you know if they were doing a good or bad job?
Your developers reassure you that things are going to work out in the
end, but it’s going to take longer then originally planned. Along with
this, your partners and investors are anxiously waiting for you to
launch the product, but something feels wrong. You’re worried that
launching it too soon could be the quick death of the entire project if
it all comes to a screeching halt due to unforeseen bugs and problems
with the application. This wasn’t how you pictured the launch of your
exciting new product and you feel a lack of confidence in the entire
process.
What can you do?
Before I get into that, let’s discuss some of the possible causes for
this situation.
- Your development team may have grossly underestimated this project.
- You might have pushed too many features into the initial release of
the product and your development team might not have done a good job
of helping you [determine what you need, not just what you
want](http://www.robbyonrails.com/articles/2006/08/22/information-anxiety-and-solutions).
```text
- Your development team might not emphasize testing enough in their
```text
process.
```text
- Your development team may have begun to take a lot of short cuts in
```text
an effort to hit your launch date(s)
```text
- Perhaps you asked for quick turnarounds on new features before an
```text
investor meeting... maybe this happened on several occasions.
```ruby
- Your development team might not be very good with Ruby on Rails,
```text
maybe this was their first Rails project.
At this point, the big question is… what’s the problem?
Can you answer this question yourself? Can your development team answer
it? If not, what do you do? How can you get an accurate understanding of
how stable the code base of your application is?
Answer: An independent code audit and review
Why is this a good idea? Well, when you have an independent team review
your code, you get the benefit of having a fresh perspective.. and often
times, an independent team can be much more critical and provide an
honest assessment in a very short period of time. This is especially
true if they have a lot of experience with the technology. For example,
PLANET ARGON has been conducting code audits
on existing projects for over two years. We’ve designed a process for
checking existing code bases for mistakes that we’ve either made
ourselves in the past or found in other projects that we’ve reviewed.
In fact, our process currently walks us through the following areas of
your Rails application.
- Security of the application
- Privacy of users’ personal data
- Adherence to the conventions of the Ruby on Rails framework
- Scalability of the application
- Performance of the application and data model
- Testing framework and process
- User interaction (when applicable)
- Information Architecture
- Model-View-Controller (MVC) implementation and organization
Not only does this process provide you with our analysis, but we also
provide you with our advice as to where your development team should
focus their attention next. If your team is lacking experience in the
areas that we recommend they focus on, we’re also here to help them
through this with our consulting services. We’re currently assisting
several Rails development teams with their testing process, refactoring,
user interaction design, optimizing their site, improving their
deployment strategy, and plan the implementation of new features.
In general, most freelancers and firms could/should provide you this
service, but it should not be performed by your existing development
team. They have a bias towards their process and this is your chance to
get a second (or third) opinion on the work that you’ve been paying them
for. If you’re spending several tens/hundreds of thousands of dollars
into this product, an independent review of your investment should be
something to seriously consider.
There are several different scenarios that could lead you to deciding to
have an independent firm perform a code audit. In fact, I’d encourage
you to always get an outside perspective of your team’s work.
You can learn more about our Ruby on Rails Code Audit
service
on our website or by giving us a call at +1 877 55 ARGON.
