iPhone app Developers | iPhone and iPad Developers

iPhone app Developers | iPhone and iPad Developers

ancestors ) ) ? $post->ID : end( $post->ancestors ); $category_title = get_the_title($root_page_id); if ( is_single() or is_category() ) { $category = get_the_category(); $parent = get_cat_name($category[0]->category_parent); //make this line go to the top level category? if (!empty($parent)) { $category_title = $parent; } else { $category_title = $category[0]->cat_name; } } if (is_date()) { $category_title = get_the_time('F Y'); } if (is_tag()) { $category_title = single_tag_title(); } if (is_author()) { $category_title = 'Author Archive'; } if (is_search()) { $category_title = 'Search Results'; } $contact_page = get_option( $shortname.'_display_contact_content'); $site_url = get_option('siteurl'); if ($post->ID != $contact_page) { ?>

Get In Touch

post_title; $category = get_the_category(); $parent = get_cat_name($category[0]->category_parent); //make this line go to the top level category? if (!empty($parent)) { $page_post_title = $parent; } else { $page_post_title = $category[0]->cat_name; //$category_link = the_permalink(); } if (is_date()) { $page_post_title = get_the_time('F Y'); } if (is_author()) { $page_post_title ='Author'; } ?>

Posts Tagged ‘proprietary technology’

Announcing free LogBuddy advanced error reporting

by in News on Jul. 24, 2011

When we announced CrashBuddy crash reporting in March, we were excited to help our clients have the best possible experience with user support, with full analysis and analytics into crashes that Apple’s reporter simply didn’t catch.  CrashBuddy has helped us identify and diagnose dozens of otherwise-unreported crashes and has greatly improved the support experience for all and our clients’ projects.

Today we’re taking things even further.  We’re announcing LogBuddy, a free technology that will begin shipping in all new projects today.  What CrashBuddy does for crashes, LogBuddy does for other types of error conditions.

LogBuddy provides advanced, real-time reporting of non-crashing error conditions that are missed by our existing CrashBuddy technology because they don’t cause crashes.  Every error or unexpected situation that a user encounters anywhere in the world is logged instantly, together with complete diagnostic information that let us reproduce, diagnose, and fix the error, and it all goes directly into our bug tracker.

But LogBuddy does much more than just log errors.  Its advanced analysis and de-duplication algorithms analyze each incident and group related incidents together, meaning that most issues append to an existing report, rather than creating a new incident for each reproduction of the same underlying error.

We’ve been secretly rolling out LogBuddy in our beta builds, enterprise products, and production software to find and catch errors.  So far, LogBuddy has identified over 300 distinct real-live error conditions in the wild that wouldn’t be traceable or reproducible via traditional means.  To be clear, this number includes our off-site alpha and beta deployments, not just consumer-facing production software.

The death knell to any project is that elusive bug that the client can reproduce once in a blue moon–but never when the developer is watching.  These are every software developer’s worst nightmare, as the time and complexity to track down these bugs can take a tremendously disproportionate amount of time and energy.

Actual LogBuddy screenshot

Fortunately, LogBuddy is always standing by to take a detailed error report, even for those issues that occur only once and can never be reproduced again.  This lets us track down problems remotely that would be otherwise impossible to examine and diagnose.  LogBuddy’s error reports contain a full stack trace of every function call on the stack, IP addresses, system configuration information, and even (optionally) a full debug log of every action taken since application start, as well as debugging information unique to a particular application.  Since LogBuddy’s reports are instant, we can often find and fix issues faster than customers can report them.

LogBuddy is so powerful and saves us so much time that we’ve decided to provide the technology free of charge to all new projects, effective today, and many of our older projects have been grandfathered in.  We’ve estimated that LogBuddy has saved us hundreds of developer hours in tracking down issues and has shaved months off project schedules.

LogBuddy lets us sort bugs by the number of times they've occurred, so we can fix the problems that affect the most people first.

LogBuddy is just the tip of the iceberg of our enormous investment into native iOS software development.  We’ve got dozens of unannounced iOS libraries in production today, and many more in development.  Learn more about how our extensive technology and depth of experience translates into accelerated development times and reduced risk for your project by getting in touch with us today.


How long will my app take?

by in News on Jul. 6, 2011

This is an important question that’s vital to making important decisions about any software project.  Unfortunately, the state of the entire software industry is that time estimates are almost never accurate.  According to the IEEE, the international engineering standards body:

This is only one of the latest in a long, dismal history of IT projects gone awry… What’s more, the failures are universally unprejudiced: they happen in every country; to large companies and small; in commercial, nonprofit, and governmental organizations; and without regard to status or reputation. The business and societal costs of these failures–in terms of wasted taxpayer and shareholder dollars as well as investments that can’t be made–are now well into the billions of dollars a year.

For one thing, software is one field in which it’s incredibly easy to snowball nontechnical people, who are often the ones providing funding for the project. I’ve seen this story play out way too many times:

It became pretty clear what Dave was really supposed to do: simulate an installation of Knowledge Essentials, run into “technical difficulties,” gather technical requirements and send them back to the developers, stall for a few days while the developers rush to build a prototype, install the prototype while explaining “technical difficulties” are preventing it from being functional, and then work closely with the marketing team to find a good excuse to reschedule the installation for a few weeks later. As soon as Dave realized this, he stormed into his manager’s office and angrily proclaimed: you’re kidding; there is no way I’m going to do this!
Three days later, Dave was on a plane headed to The Netherlands. They say everyone has a price; Dave’s was a 20% bonus and an extra week’s vacation.

As margins shrink, there’s increasing pressure for even the best firms to employ tactics like this.  It’s become so commonplace that programmers joke about how much they can get away with over drinks.

But it’s not just dishonesty that’s the problem.  Even when everyone means well, schedules are almost always worse than worthless.  From Rapid Development:

If Las Vegas sounds too tame for you, software might just be the right gamble. Software projects include a glut of risks that would give Vegas oddsmakers nightmares. The odds of a large project finishing on time are close to zero. The odds of a large project being canceled are an even-money bet (Jones 1991).

In 1998, Peat Marwick found that about 35 percent of 600 firms surveyed had at least one runaway software project (Rothfeder 1988). The damage done by runaway software projects makes the Las Vegas prize fights look as tame as having high tea with the queen. Allstate set out in 1982 to automate all of its office operations. They set a 5-year timetable and an $8 million budget. Six years and $15 million later, Allstate set a new deadline and readjusted its sights on a new budget of $100 million. In 1988, Westpac Banking Corporation decided to redefine its information systems. It set out on a 5-year, $85 million project. Three years later, after spending $150 million with little to show for it, Westpac cut its losses, canceled the project, and eliminated 500 development jobs (Glass 1992). Even Vegas prize fights don’t get this bloody.

The dirty secret about the software industry is that time and cost estimates are worse than guesses.  Nobody wants to talk about it, because they’re afraid everyone will discover that the emperor has no clothes.

Our Estimates

We’ve worked at a lot of firms with the industry-standard terrible software schedules, and when we formed our own company, we knew we could do better.  At DrewCrawfordApps, we pride ourselves on creating the most accurate estimates in the industry.

We use a modified form of Evidence-Based Scheduling, a scientific method that gives us incredibly accurate insights into our software schedules.  We start by breaking every project into small tasks, so small that each task is at most a few hours.  Projects may have hundreds or thousands of tasks, from planning, testing, development, feedback, maintenance, and more.  This granularity helps us estimate projects and keeps us honest about the work involved.

Obviously the first ingredient to accurate estimates is having experienced developers write them, instead of sales people.  Our estimates are always written by senior-level developers, and we perform extensive cross-checking by independently estimating items and comparing the estimates.  It sounds obvious, but many firms don’t invest the effort in getting it right.

We then estimate each individual task.  But we don’t just trust the estimates we write–we correlate them against previous work.  So if we estimate a task at 30 minutes, we don’t write 30 minutes on the schedule–we write down the average amount of time we’ve historically spent on things that were originally estimated at 30 minutes.  We have a wealth of historical information and complex algorithms that do the number-crunching for us.  For instance, here’s my estimation history:


You can see that my estimates are slightly pessimistic–what I estimate at five hours is usually four and a half.  But I have a few really bad estimates and a few really good estimates.  Our software corrects my estimates, so when I estimate a task at five hours, it writes it down as 4.5 hours.  But it also builds a full probability distribution–there’s a 10% chance it could be as bad as 10 hours, and a 10% chance it could be as good as 30 minutes.

Determining Ship Dates

We take all of these probability distributions for all of these individual tasks, aggregate them across all of our developers, and we are able to forecast our ship dates the way meteorologists forecast the weather (but with a lot more accuracy!).  Here’s a completion graph for one of our projects:

This project is on schedule.  There’s an 80% chance we will ship on time, and a 50% chance that we will ship a week early.  (We’re the only firm that ever ships projects early.)  This is a live report, that’s always up-to-date, telling us exactly when the project will ship.

Developer Timelines

But it’s not just about measuring delivery dates.  Our advanced systems can also predict individual developers’ schedules hour-by-hour:

Here you can see that on Saturday I’ll probably be working on “core2″, but there’s some chance I could be working on other things.  There’s a 4% chance I will be blocked and waiting for information from a client or one of our developers, which is good information to know.  If that number gets too high, I can take proactive steps to reduce that risk and keep the process flowing smoothly.  We construct color-coded timelines like this for every project and every developer, which helps us predict and proactively address slips well before they occur.

It’s important that we block out time for particular tasks.  It’s possible to ship a 100-hour project in two weeks–in theory.  In practice, we work on many projects at once, and it’s important to balance our time commitments effectively.  We can’t just drop everything we do and work on a new project, as that wouldn’t be fair to our existing clients.  Tracking individual developer timelines on individual tasks forces us to be honest about the amount of work we have currently on our plate and our ability to commit to new projects to maintain our high standards to clients and customers.

Data Collection

Our estimation algorithms are only as good as the data we can collect.  If logging time becomes too much of a hassle for our developers, we won’t have accurate historical data, and that means bad scheduling predictions.  Thankfully, we’ve invested in complex proprietary tools that automatically log our time with minimal effort.  There’s one step to start work on a project which automatically finds the correct version of the software to work on, downloads it to the developer’s local computer, and starts tracking time.  We’ve made it more difficult not to collect data.  This lets us correlate every individual change to a piece of software with an estimation item, meaning that every time we work on something, we’re collecting data to improve our scheduling forecasts.  As a result, we’ve collected tens of thousands of points of data.

The Result

What does this mean for you, the client?  It means that our estimates are more than just pieces of paper.  Every date, figure, and number has a wealth of expertise and research backing it up, and that’s why we have the most accurate estimates in the industry.  We hit our targets over 90% of the time, whereas the industry average has recently improved to 34%.

Unfortunately, it also means that we lose some work when we claim, accurately, that a project will cost $25,000 and take four months to deliver and a competitor claims, inaccurately, that it will cost only $10,000 and take two months.  But we think it’s more important that our clients feel comfortable relying on us for accurate information about their software projects than it is for us to win every contract.

If you’re interested in getting an accurate estimate for your software project, get in touch with us today!


Developing location-based applications

by in News on Jul. 1, 2011

Writing location-based mobile apps is an enormous growth area right now.  As one of Austin’s leading iPhone development companies, we are seeing more proposals for location-based applications than ever before.  From location-aware games and “foursquare-like” social applications to hardcore land surveying, fleet-tracking, applications, to location-aware audio tours or custom traditional tour or routing applications, location technology is here to stay.

If you want to develop software that takes advantage of the iPhone, iPad, or iPod Touch’s location features, there are many factors to consider when designing and planning your application.

Proximity-based searches

Google Maps and Yelp both return local results, allowing you to search a world-wide database returning only local items.  This is a very common requirement for location-based applications: social applications may want to display a list of nearby users, mapping or tracking applications may want to display a few nearby items.  Although Google and Yelp make it look easy, in reality this is an incredibly difficult problem.  It only gets more difficult when you have thousands, millions, or tens of millions of potential search results in a database.

Many contractors who haven’t worked with proximity-based searching before use a naive approach that gets exponentially slower and slower as new users download your app!  But at DrewCrawfordApps, we’re the leading experts in implementing proximity searching on iOS, with algorithms that scale into the millions of users.  Since we believe strongly that location-aware applications are the future, we’ve invested years of development into our proprietary location technology, which can accurately find nearby users or items from databases of millions in milliseconds.

And unlike Google or Yelp’s algorithms, which are designed for fixed points (i.e. brick-and-mortar buildings) that don’t move or are always available, our software stack is built from the ground up to handle fast-moving mobile devices that change position rapidly and lose network connectivity that cause “cache churn” on other systems.

In short, if you need proximity search, you need us working on your project.

Battery life considerations

The GPS chip is one of the most power-hungry components in an iPhone, and can completely drain the battery in less than two hours.  Particularly if you’re using background location services, a method of continuing to collect location information in the background, it’s important to design algorithms that can give you the location information you need while having a minimal impact to users’ battery life.  Background location looks easy to implement, until your iPhone overheats and shuts off after running for an hour.

At DrewCrawfordApps, we’ve developed complex code to dial-up and dial-down power consumption of location hardware to provide acceptable tradeoffs for short-term and long-term location services to meet many particular usage scenarios.  We take advantage of special power-saving modes on newer devices, while falling back gracefully on older ones.  We’ve done extensive battery life testing and we know the limitations of the hardware inside and out.  We are even able to remotely scale up and scale down location hardware in response to external events (turning up accuracy in response to another user in close proximity, for example).


For professional mapping applications, accurate geographical calculations are critical.  In addition to the original geographical area calculation algorithms on display in the CrowdSize and uScaleit+ consumer applications, we’ve developed professional-grade 2D and 3D geographical systems for computing area, perimeter, volume, surface area, and many more.  Our extensive experience, not only in iOS software development, but in mathematics and theoretical computer science, gives us a wealth of resources to solve even the most complex engineering problems.

We’ve also developed applications utilizing the ESRI ArcGIS geographic server system for performing even more complex, enterprise-grade, networked calculations.  ArcGIS is an extremely powerful (but extremely complex) geographic information system which can be extended to perform just about any type of computation in the palm of your hand.

Even basic calculations, such as triggering an event when an iPhone is within a certain distance of a landmark, are problematic if performed incorrectly.  Since our ellipsoidal world is a non-euclidian space, most distance approaches will not work.  Even the distance calculations performed by iOS use a spherical underlying model, which can have an error of 10km or more.  Our geospatial distance formulas can return values accurate to the centimeter in milliseconds.  This is the level of technical expertise you need for your location-based mobile app to be successful.

Background Location

Our background location experience lets us process locally, and even remotely, location change events with a minimal impact to battery life.  We can report location changes to your backend servers or even build a system for you that lets you view and track devices as they move across the globe.  Other uses include tour applications, audio tour applications, and other applications designed for museums, theme parks, art exhibits, or amusement parks.

External hardware

When the on-device GPS isn’t accurate enough, we have experience integrating with external GPS units for increased accuracy to perform specialized location tracking.  External hardware can sharply reduce the variance in GPS readings and can help eliminate error and provide for faster location locking.

Location-based app development

If you’re searching for a developer for your location-based application, look no further.  We believe strongly that GPS-powered software is the future for mobile application development, and our huge investment in proprietary location technology reflects our commitment to location-aware applications.  Our advanced technology makes us among the world’s leading experts in iOS location-based software, representing a breadth and depth of experience that cannot be matched by multiplatform or “generalist” development shops.  Contact us today to learn about how we can leverage our extensive experience for your iPhone or iPad app.


Announcing Placeholder Image Maker

by in News on Jun. 17, 2011

Austin developer DrewCrawfordApps LLC is pleased to announce the release of Placeholder Image Maker for Mac, a fast and easy way for developers and designers to create placeholder artwork for their projects in seconds.
Many application and web developers know the pain and frustration of waiting for the art team to finally deliver the artwork and long e-mail threads clarifying the necessary sizes and formats for artwork. This wastes developer and designer time and contributes to project delays.No more! Placeholder Image Maker is a lightweight, single-purpose tool that lets developers and designers create placeholder artwork in seconds. Simply choose a color and a size and your placeholder artwork can be saved to disk or dragged into your project.
Placeholder Image Maker’s UI is designed for maximum speed and efficiency, making lengthy Adobe Photoshop launch times a thing of the past. Every change you make is displayed live, with no need to confirm or cancel any settings. Drag-and-drop export into your favorite application makes creating, exporting, and using your placeholders a one-click operation.
All images are stamped with pixel sizes for clear communication to the art team about the size of each placeholder and where it will be used in the final product.
Placeholder Image Maker can match background and foreground colors via web hex, a system-wide color picker, RGB values, and many other convenient color entry methods.

  • Create placeholder artwork in seconds. Set a size, pick some colors. Done.
  • Drag-and-drop export into your favorite application.
  • Epic color pickers including RGB, CMYK, system palettes, a system-wide color picker/eye dropper, web hex, color wheels, and many more
  • Customize placeholder text
  • Pixel sizes stamped on all artwork for clear communication about final artwork sizes
  • Instant previews, no need to confirm any changes
  • No settings, nothing to configure, launches instantly

“We conceived, designed, and developed Placeholder Image Maker in less than 24 hours,” said Drew Crawford, Lead Developer, “including learning the Mac platform for the first time. It’s been an invaluable tool supporting our iOS app developers internally and we’re happy to make it available today to the development community at large.”
System Requirements:

  • Mac OS X 10.6.6 or later
  • Intel 64-bit processor

Placeholder Image Maker is available in the Mac App Store in the Developer Tools category for $0.99, or at this website.
DrewCrawfordApps is a small, independent contract iOS developer located in Austin, TX, and has developed over a dozen iPhone, iPod Touch, and iPad applications including consumer, enterprise, and government projects in the Top 100, 200, and 300 both in the US and internationally.
© 2011 DrewCrawfordApps LLC. All Rights Reserved. Apple, the Apple logo, iPhone, iPod and iPad are registered trademarks of Apple Inc. in the U.S. and/or other countries.

Announcing free CrashBuddy advanced diagnostics

by in News on Mar. 25, 2011

As a leading developer of iPhone and iPad Touch applications, our clients have come to trust us to deliver the best iOS experience possible.

But unlike other developers who focus only on contract development services, we also write and support our own applications in-house. We understand customer and support pain points like no other for-hire software developer. In addition to being “just” a great iOS developer, we draw on our experience building and designing our own applications to make our clients’ lives easier.

Crashes tend to make customers angryOne of the biggest problems in customer support is diagnosing application crashes. Customers can report crashes that are difficult to reproduce in-house or that seem to be unexplainable. To further complicate matters, Apple’s crash reporter is unreliable and does not always deliver the information necessary for developers to identify and fix these crashes. In addition, upwards of 75% of iOS users have disabled crash reporting, so you may never even find out that your users are experiencing a crash. Even if Apple’s crash reporter happens to work and if the customer has enabled crash reporting, many app developers forget to check their iTunes accounts for crash reports or do so only sporadically. In practice, we suspect over 98% of crashes go completely unreported.

Today we’re announcing CrashBuddy, our new, proprietary, iPhone, iPod Touch, and iPad crash reporting technology. CrashBuddy ensures that crash reports are instantly sent to us, every time. It works independently of Apple’s crash reporter and whether or not users have crash reporting enabled to ensure that every crash, anywhere in the world, is always reported along with complete diagnostic information so the crash can be reproduced and fixed. We drew heavily on our depth of experience remotely diagnosing and fixing crashes to engineer a solution that is the best in class in crash reporting and diagnostics.

Advanced analytics and reportingBut CrashBuddy does more than just send error reports. Every crash is automatically categorized and root-caused by a proprietary algorithm so we know exactly how many customers are affected by the crash, exactly what part of the application is causing the crash, and how often an individual customer is affected, everywhere in the world. We also strip all private information from crash reports as part of our commitment to users’ privacy.

We’ve been rolling out CrashBuddy to some of our applications as a test over the last month, and the results have been wildly successful. We’ve been able to fix rare and odd crashes that were previously undiagnosable and unreproducible, and we now have the confidence of exact figures and statistics to guide our updates and bug fixes going forward. But instead of keeping this technology to ourselves, we want our clients to benefit from our hard work solving this difficult problem.

Today we’re announcing that every app we build for our clients going forward will have CrashBuddy advanced crash reporting and diagnostics “baked in” at no charge. We want every client to benefit from our advanced reporting so that we have the best possible information to diagnose and understand the impact of application crashes. This breakthrough technology is not available from any other vendor and is just one more way that we stand head and shoulders above the competition. We’re much more than just another developer–we’re your partner in delivering an awesome experience for your customers. Contact us today to find out about developing your app with this advanced diagnostic capability.