2

Based on FP table here:

http://www.qsm.com/resources/function-point-languages-table

Here are average FP value for 3 different languages

Java --> 53

J2EE --> 46

.Net --> 57

As I understand the FP estimation uses these values to calculate the effort size. Example: My FP estimation provides a size of 10, so the effort size will be:

Java --> 530

J2EE --> 460

.Net --> 570

Considering this should I choose J2EE as the language of choice because it has the lowest effort value size? Does a lower FP average value mean lesser effort required? If so why?

  • 1
    @MarvMills Acknowledged, added more details so that it may make more sense. – Ayusman Aug 7 '15 at 9:07
2

The gearing factor which is shown in the table, is just the amount of source line codes in a language that, in average, correspond to one function point.

These projects are from QSM's data, and will vary much from organization to organization and even team to team. QSM note this on the page as well.

Even if the data was 100% correct and applicable in all environments, it still doesn't show you which language has the lowest effort. It really only indicates how verbose the syntax is for each language.

For example PowerBuilder takes in average only 26 lines, whereas J2EE is 46 and C# is 54. This would indicate Powerbuilder to be much more efficient. In reality, Powerbuilder is a 4gl language which indeed is very efficient, but only for a pretty narrow type of application (CRUD desktop client/server apps). Writing a modern web-app in Powerbuilder however, would take orders of magnitude more effort than writing it in C#.

So this table is certainly nothing that should factor into a choice of technology. A much better factor in choosing tech, is as simple as whatever your team is more experienced in.

0

I'm not a complete Function Point expert, but it seems like you're trying to choose a technology based on the size. You've estimated that your software is going to be 10 function points. The table you linked to provides conversions between function points and logical source lines of code. Both are size that is then used to estimate the effort required.

I'm not sure how you want to go from function points to effort. There are different equations for doing that. Since you can convert from function points to SLOC, there are also tools and equations for estimating effort based on SLOC. I've used COCOMO II before, which allows for inputs in both SLOC and FP. There are others, though.

The models that I'm familiar with require more inputs than just the size of the software under construction. Consider the level of understanding of the domain, the amount of documentation that is required, the cohesion of the team, the capability and knowledge of the individuals in each role, the experience on the platform and language (and with the existing codebase, if one exists), the familiarity with the tools and work environment, and colocation (or lack thereof) of the development team. Inputs such as these are used along with the size to actually produce your estimate.

You shouldn't choose a language based on the effort. Choose a language that appropriately solves the problems at hand that allows you to affect factors that go into the final effort estimation.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.