<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css" media="screen">
<meta name="author" content="Tinuola Awopetu">
<meta name="keywords" content="NetBeans IDE, NetBeans Platform, CBPinc, Smart Trac">
  <title>With Help from NetBeans, Teaming Up to Curb Drunk Driving</title>
  <script type="text/javascript" language="javascript" src="../../images_www/js/lytebox-compressed.js"></script>
  <link rel="stylesheet" href="../../lytebox.css" type="text/css" media="screen" />
</head>
<body>
<h1>With Help from NetBeans, Teaming Up to Curb Drunk Driving</h1>
<br>
<img alt="CPBinc Logo" src="../../images_www/articles/cpbinc-smartrac/cpb-inc-logo.gif"
 style="width: 96px; height: 60px;" align="left" hspace="5" vspace="5"><br>
&nbsp;By their count, the developers at <a
 href="http://www.cpbinc.com/">C. Pitman Baker &amp; Associates</a>
handle a roster of 10 software development projects at any given time,
of which six or seven are Java-based and built solely using the
NetBeans platform. It would not be a stretch to call them enthusiastic
fans of the NetBeans IDE.<br>
<br>
&#8220;NetBeans is the only environment we use,&#8221; Chief Operating Officer Chris Gamble said in a recent interview. &#8220;NetBeans runs the gamut on
flexibility and complicity, which is why we continue to use it for
every project in Java. It gives us everything we need to get projects
done regardless of the skill level of the developer. It&#8217;s a great
system.&#8221;<br>
<br>
Based in Irving, Texas, CPBinc is a software consulting and design firm
that provides e-commerce solutions, enterprise resource planning (ERP)
systems and custom software development to small and mid-sized companies
in a range of industries: Telecom, Banking, Oil &amp; Gas,
Manufacturing, and more. The company and its team of developers have
been NetBeans users since version 3.6.<br>
<br>
&#8220;We&#8217;ve occasionally looked at other IDEs&#8212;Eclipse and Jbuilder&#8212;to see
where things stand, but what we keep coming back to is that the
NetBeans tool set is extremely mature and very stable.&#8221;<br>
<br>
Gamble&#8217;s opinion of the NetBeans IDE was echoed by lead developer
Kabilan Makendra and Mark Hughey, head of Sales &amp; Marketing, when all
three gathered to discuss the experience of using NetBeans 5.0 to build
an integrated business application system called SMARTRAC for a client.<br>
<br>
<center>
    <a
        href="../../images_www/articles/cpbinc-smartrac/screens.png" rel="lytebox">
        <img alt="" src="../../images_www/articles/cpbinc-smartrac/screens.png" style="width: 402px; height: 321px;"></a> 
    <a
        href="../../images_www/articles/cpbinc-smartrac/appointment.png" rel="lytebox">
            <img alt="" src="../../images_www/articles/cpbinc-smartrac/appointment.png" style="width: 404px; height: 321px;"></a>
</center>
<br>
<div style="text-align: center;"><small style="font-style: italic;">(Click
on images for full-size view.)</small><br>
</div>
<br>
The client, <a href="http://www.smartstartinc.com/">Smart Start</a>, a
leading provider of ignition interlock
systems, works with judicial agencies around the United States to
monitor the driving habits of convicted drunk drivers. The interlock
system is an in-car alcohol breath screening device that disables the
vehicle if the driver is intoxicated. When Smart Start teamed up with
CPBinc, it wanted a single operating system that would streamline all
aspects of its business: from tracking the manufacture, sale, 
installation and repair of the interlock devices, to collecting data 
from installed devices and creating reports for the court systems. They also 
wanted a web interface that would give judges and probation officers access 
to the reports. The main 
objective, according to CPBinc, was to enable Smart Start to
concentrate on the task of "separating drinking from driving".
<br>
<br>
Lead developer Makendra and his team credits the NetBeans Profiler tool
for helping with a particular challenge during the Smart Start project:
the company&#8217;s low-power computers.<br>
<br>
&#8220;When we rolled out the project they still had machines running on 64MB
of memory,&#8221; the developer said. &#8220;We had to create a system that could
operate under those constratints. Profiler showed where we were taking
more memory and time and we knew where to make improvements.&#8221;<br>
<br>
Makendra also gave high marks to the IDE&#8217;s refactoring tool, calling it
a timesaver for moments when adjustments need to be made mid-way
through projects. <br>
<br>
Smart Start has been running the new ERP system across its 400 service
centers since August 2006, and has seen improvements in its
operations. In a written statement about the new system, the company president,
Jim Ballard said: &#8220;SMARTRAC has given us much more process control at
our service facilities and ultimately will help us provide better
service to our customers and the courts."<br>
<br>
CPBinc recently ported over from NetBeans 3.6 to NetBeans 5.5 and with
minimal difficulty or retraining needed for its developers. Citing
positive feedback from clients, the company plans to continue using the
NetBeans IDE for future projects.<br>
<br>
&#8220;For one client, using NetBeans we built a system that runs their
entire company,&#8221; Gamble said. &#8220;After, the owner told us his company
could lose everything, but the system we built would still be
functioning. It&#8217;s always good to hear things like that about your work.&#8221;<br>
<br>
</body>
</html>
