DESC:FIELD
The present disclosure relates to a tool for refining a crude software product.
BACKGROUND
The background information herein below relates to the present disclosure but is not necessarily prior art.
User experience plays a vital role in success of any developed product, system, or application. Typically, in the field of e-commerce the impact of user experience is up to 60 %. Due to rapid rate of development and proliferation of products that enhance user experience, it is often noticed that the users are required to go through high degree of learning in order to properly operate and gain the advantage of such products. Since users belonging to different geographical locations tend to have different liking’s and disliking’s the product is required to be developed based on target users. In addition, interfaces for applications have increased the possibility of confusion to the users in an attempt to provide application operators with more choices for improved productivity.
Therefore, there is felt a need to provide a tool for refining a crude software product that alleviates the abovementioned drawbacks, and evaluates the functionality, usability, aesthetics, and emotional connect, the product creates with the end customers.
OBJECTS
Some of the objects of the present disclosure, which at least one embodiment herein satisfies, are as follows:
An object of the present disclosure is to provide a tool for refining a crude software product.
Another object of the present disclosure is to provide a tool which ensures that different aspects for development of product are incorporated and verified by end users during development cycle.
Another object of the present disclosure is to provide a tool which validates product to determine that the product meets customer expectation.
Yet another object of the present disclosure is to provide a tool which quantify feedback from user experience.
Another object of the present disclosure is to provide a tool that measures the performance of product in development stage on a specific scale for guaranteeing that the needs, wants and aspirations of customers are in conformance with the product being developed.
An object of the present disclosure is to provide a tool that enhances user experience.
Other objects and advantages of the present disclosure will be more apparent from the following description, which is not intended to limit the scope of the present disclosure.
SUMMARY
The present disclosure envisages a tool for refining a crude software product.
The tool for refining a crude software product comprises a repository, an input module, an analyzer, a digital formulator, a prototype generator, a functionality verification module, a look and feel parameter verification module, and a product development module.
The input module is configured to receive comments from users testing the crude software product. In an embodiment, the input module can be selected from a group consisting of a gesture enabled input unit, a voice enabled input unit, a standard keyboard, a touchscreen, or any combination thereof.
The repository is configured to store a set of pre-determined formularization rules, a list of pre-determined thresholds, and a task table having a pre-determined list of testing tasks and corresponding the users assigned to execute each of the testing task.
The analyzer is configured to cooperate with the input module, and further configured to parse and analyses each of the inputted comments to generate an analysis.
The analyzer comprises analyzer comprises a parser and an analyzing module. The parser is configured to cooperate with the input module to parse the received comments into tokens. The analyzing module is configured to cooperate with the parser to analyses the tokens based on a set of pre-determined analysis rules stored in the repository.
The digital formulator is configured to cooperate with the analyzer and the repository to formularize a solution based on the analysis, with the help of the formularization rules.
The prototype generator is configured to cooperate with the repository and the digital formulator, and is further configured to generate a prototype comprising a refined version of the crude product based on the formularized solution and the formularization rules.
The functionality verification module is configured to cooperate with the prototype generator to receive the prototype for checking functionality of the prototype, and further configured to generate a check result based on the checking. The functionality verification module is further configured to provide a failure comment to the input module in case of failure of functionality of the prototype.
The look and feel parameter verification module is configured to cooperate with the functionality verification module to receive the functionally verified refined prototype and compute look and feel parameters by testing the functionally verified refined prototype based on executing the testing tasks stored in the task table and the thresholds. The look and feel parameter verification module is further configured to generate a result based on the computation and provide the result to the input module.
The look and feel parameter verification module includes a look and feel computation module and a result computation module. The look and feel computation module is configured to cooperate with the functionality verification module to receive the functionally verified refined prototype and compute the look and feel parameters by testing the prototype based on the task table and the thresholds. The result computation module is configured to cooperate with the look and feel computation module to generate the result based on the computation.
In an embodiment, the look and feel parameters includes usability assessment, aesthetics assessment, and satisfaction and emotions assessment.
In another embodiment, the thresholds can be selected from the group consisting of time taken to complete the testing task and interaction of the users while executing the testing tasks.
The look and feel computation module includes a usability assessment module, an aesthetics assessment module, and a satisfaction and emotional level assessment module. The usability assessment module configured to cooperate with the functionality verification module to assess the usability of the functionally verified refined prototype. The aesthetics assessment module configured to cooperate with the functionality verification module to assess the aesthetics of the functionally verified refined prototype. The satisfaction and emotional level assessment module configured to cooperate with the functionality verification module to assess the satisfaction and emotional level of the functionally verified refined prototype.
The usability assessment module includes a first matrix generator, a second matrix generator, an effectiveness calculator, and an efficiency calculator.
The first matrix generator is configured to cooperate with the functionality verification module to generate a first matrix based on the time taken to complete the execution of the testing tasks.
The second matrix generator is configured to cooperate with the functionality verification module to check a status of success or failure on completion of the testing tasks, and further configured to generate a second matrix based on the status.
The effectiveness calculator is configured to cooperate with the second matrix generator to generate effectiveness percentage by calculating a first percentage of total successful testing tasks completed.
The efficiency calculator is configured to cooperate with the first matrix generator and the second matrix generator to calculate a first count of total number of the users and a second count of total number of the testing tasks assigned from the second matrix using a counter. The efficiency calculator is further configured to calculate time based efficiency and overall relative efficiency based on the first count, the second count, the time taken to complete the execution of the testing tasks, and the status of completion of the testing tasks.
The aesthetics assessment module comprises a rating module, a third matrix generator, and an aesthetic calculator.
The rating module is configured to cooperate with the functionality verification module to receive at least a first set of ratings provided for a first pre-determined set of questionnaires, stored in the repository, by the users for the functionally verified refined version. The third matrix generator is configured to cooperate with the rating module to generate a first matrix based on the first set of ratings received from each of the user. The aesthetic calculator is configured to cooperate with the matrix generator to calculate the aesthetics by calculating a second percentage of a first average of the first set of ratings based on the first matrix.
The satisfaction and emotional level assessment module comprises a satisfaction level calculator and an emotional level calculator.
The satisfaction level calculator is configured to cooperate with the functionality verification module to receive a second set of ratings for a second pre-determined set of questions, stored in the repository, from each of the users, and is further configured to calculate a satisfaction level of the users by calculating a second average of the second set of ratings.
The emotional level calculator is configured to cooperate with the functionality verification module to receive a third set of ratings for a third pre-determined set of questions, stored in the repository, from each of the users, and further configured to calculate an emotional level of the users by calculating a third average of the third ratings.
In an embodiment, tool may include a plurality of tracking devices for tracking brain waves to capture current emotional state of the users.
The product development module is configured to cooperate with the look and feel parameter verification module to cyclize the prototype over a number of iterations, using an iterator, until the comments received from the input module equals to zero, and is further configured to finalize the prototype to a final software product.
The analyzer, digital formulator, prototype generator, functionality verification module, and look and feel parameter verification module, and product development module are implemented using one or more processor(s).
The present disclosure envisages a method of refining a crude software product.
BRIEF DESCRIPTION OF ACCOMPANYING DRAWING
A tool for refining a crude software product will now be described with the help of the accompanying drawing, in which:
Figure 1 illustrates a schematic block diagram of a tool for refining a crude software product;
Figure 2 illustrates a schematic block diagram of look and feel computation module of Figure 1; and
Figures 3a, 3b and 3c illustrate a flow diagram for a method of refining a crude software product.
LIST OF REFERENCE NUMERALS USED IN THE DESCRIPTION AND DRAWING
Reference Numeral Reference
100 Tool
102 Repository
104 Input module
106 Analyzer
108 Digital formulator
110 Prototype generator
112 functionality verification module
114 Iterator
116 look and feel parameter verification module
118 product development module
120 parser
122 Analyzing module
124 look and feel computation module
126 result computation module
128 usability assessment module
130 aesthetics assessment module
132 satisfaction and emotional level assessment module
134 first matrix generator
136 second matrix generator
138 effectiveness calculator
140 efficiency calculator
142 counter
144 rating module
146 Third matrix generator
148 aesthetic calculator
150 satisfaction level calculator
152 emotional level calculator

DETAILED DESCRIPTION
Embodiments, of the present disclosure, will now be described with reference to the accompanying drawing.
Embodiments are provided so as to thoroughly and fully convey the scope of the present disclosure to the person skilled in the art. Numerous details, are set forth, relating to specific components, and methods, to provide a complete understanding of embodiments of the present disclosure. It will be apparent to the person skilled in the art that the details provided in the embodiments should not be construed to limit the scope of the present disclosure. In some embodiments, well-known processes, well-known apparatus structures, and well-known techniques are not described in detail.
The terminology used, in the present disclosure, is only for the purpose of explaining a particular embodiment and such terminology shall not be considered to limit the scope of the present disclosure. As used in the present disclosure, the forms "a,” "an," and "the" may be intended to include the plural forms as well, unless the context clearly suggests otherwise. The terms "comprises," "comprising," “including,” and “having,” are open ended transitional phrases and therefore specify the presence of stated features, elements, modules, units and/or components, but do not forbid the presence or addition of one or more other features, elements, components, and/or groups thereof.
A tool for refining a crude software product of the present disclosure, is described with reference to Figure 1 through Figure 3c.
Referring to Figure 1, the tool (100) for refining a crude software product comprises a repository (102), an input module (104), an analyzer (106), a digital formulator (108), a prototype generator (110), a functionality verification module (112), a look and feel parameter verification module (116), and a product development module (118).
The input module (104) is configured to receive comments from users testing the crude software product. In an embodiment, the input module (104) can be selected from a group consisting of a gesture enabled input unit, a voice enabled input unit, a standard keyboard, a touchscreen, or any combination thereof.
Testing users are those “users” who represent the end user community who will be actually using the product. In an embodiment, the testing users are identified by the digital formulator.

The repository (102) is configured to store a set of pre-determined formularization rules, a list of pre-determined thresholds, and a task table having a pre-determined list of testing tasks and corresponding the users assigned to execute each of the testing task.
The analyzer (106) is configured to cooperate with the input module (104), and further configured to parse and analyse each of the inputted comments to generate an analysis.
The analyzer (106) comprises a parser (120) and an analyzing module (122).
The parser (120) is configured to cooperate with the input module (104) to parse the received comments into tokens.
An exemplified pseudocode for the parser (120) is given below:
Program (parser)
Read comments
Do
{
parse the received comments into tokens.
} While (Read comments)
End
The analyzing module (122) is configured to cooperate with the parser (120) to analyses the tokens based on a set of pre-determined analysis rules stored in the repository (102).
An exemplified pseudocode for the analyzing module (122) is given below:
Program (analyse)
Read tokens
Do
{
analyses the tokens based on a set of pre-determined analysis rules.
} While (Read tokens)
End
The digital formulator (108) is configured to cooperate with the analyzer (106) and the repository (102) to formularize a solution based on the analysis, with the help of the formularization rules. In an embodiment, the digital formulator (108) employ a persona identification technique to identify users.

An exemplified pseudocode for the digital formulator (108) is given below:
Program (formulator)
Read analysis
Do
{
formularize a solution based on the analysis, with the help of the formularization rules.
} While (Read analysis)
End
In an embodiment, the minimum number of users are determined as follows:
For each Persona Type
three novice users;
three users with some prior knowledge / experience in identical / same area; and
three power users.

The prototype generator (110) is configured to cooperate with the repository (102) and the digital formulator (108), and is further configured to generate a prototype comprising a refined version of the crude product based on the formularized solution and the formularization rules.
An exemplified pseudocode for the prototype generator (110) is given below:
Program (prototype generator)
Read formularized solution and the formularization rules.
Do
{
generate a prototype comprising a refined version of the crude product based on the formularized solution and the formularization rules.
} While (Read formularized solution and the formularization rules)
End

The functionality verification module (112) is configured to cooperate with the prototype generator (110) to receive the prototype for checking functionality of the prototype, and further configured to generate a check result based on the checking. The functionality verification module (112) is further configured to provide a failure comment to the input module (104) in case of failure of functionality of the prototype.
An exemplified pseudocode for the functionality verification module (112) is given below:
Program (functionality verification)
Read prototype
Do
{
checking functionality of the prototype;
generate a check result based on the checking; and
provide a failure comment to the input module (104) in case of failure of functionality of the prototype.
} While (Read prototype)
End

The look and feel parameter verification module (116) is configured to cooperate with the functionality verification module (112) to receive the functionally verified refined prototype and compute look and feel parameters by testing the functionally verified refined prototype based on executing the testing tasks stored in the task table and the thresholds. The look and feel parameter verification module (116) is further configured to generate a result based on the computation and provide the result to the input module (104).
In an embodiment, the testing tasks may be defined for each persona type. In another embodiment, same testing tasks may be used for different persona types. In yet another embodiment, the testing tasks are test cases of the conventional testing.

The look and feel parameter verification module (116) includes a look and feel computation module (124) and a result computation module (126).
The look and feel computation module (124) is configured to cooperate with the functionality verification module (112) to receive the functionally verified refined prototype and compute the look and feel parameters by testing the prototype based on the task table and the thresholds.
The result computation module (126) is configured to cooperate with the look and feel computation module (124) to generate the result based on the computation.
An exemplified pseudocode for the result computation module (126) is given below:
Program (result computation)
Read computation
Do
{
generate the result based on the computation
} While (Read computation)
End

In an embodiment, the look and feel parameters includes usability assessment, aesthetics assessment, and satisfaction and emotions assessment.
In another embodiment, the thresholds can be selected from the group consisting of time taken to complete the testing task and interaction of the users while executing the testing tasks.
Referring to Figure 2, the look and feel computation module (124) includes a usability assessment module (128), an aesthetics assessment module (130), and a satisfaction and emotional level assessment module (132). The usability assessment module (128) configured to cooperate with the functionality verification module (112) to assess the usability of the functionally verified refined prototype. The aesthetics assessment module (130) configured to cooperate with the functionality verification module (112) to assess the aesthetics of the functionally verified refined prototype. The satisfaction and emotional level assessment module (132) configured to cooperate with the functionality verification module (112) to assess the satisfaction and emotional level of the functionally verified refined prototype.
The usability assessment module (128) includes a first matrix generator (134), a second matrix generator (136), an effectiveness calculator (138), and an efficiency calculator (140).
The first matrix generator (134) is configured to cooperate with the functionality verification module (112) to generate a first matrix based on the time taken to complete the execution of the testing tasks.
An exemplified pseudocode for the first matrix generator (134) is given below:
Program (first matrix generator)
Read time taken to complete the execution of the testing tasks.
Do
{
generate a first matrix based on the time taken to complete the execution of the testing tasks
} While (Read time taken to complete the execution of the testing tasks)
End

The second matrix generator (136) is configured to cooperate with the functionality verification module (112) to check a status of success or failure on completion of the testing tasks, and further configured to generate a second matrix based on the status.
An exemplified pseudocode for the second matrix generator (136) is given below:
Program (second matrix generator)
Read status of success or failure on completion of the testing tasks
Do
{
check a status of success or failure on completion of the testing tasks; and
generate a second matrix based on the status.
} While (Read status of success or failure on completion of the testing tasks)
End
In an embodiment, the table 1 below illustrates the first and second matrix generated.
Persona Type Time taken by users per testing task Enter nij = 1 if testing task was successful else enter nij=0
Users Task 1 Task 2 Task 3 Task 4 Task 1 Task 2 Task 3 Task 4
User 1 t11 t12 t13 t14 n11 n12 n13 n14
User 2 t21 t22 t23 t24 n21 n22 n23 n24
User 3 t31 t32 t33 t34 n31 n32 n33 n34
User 4 t41 t42 t43 t44 n41 n42 n43 n44
User 5 t51 t52 t53 t54 n51 n52 n53 n54
(Table 1)

The effectiveness calculator (138) is configured to cooperate with the second matrix generator (136) to generate effectiveness percentage by calculating a first percentage of total successful testing tasks completed.
An exemplified pseudocode for the effectiveness calculator (138) is given below:
Program (effectiveness calculator)
Read second matrix
Do
{
generate effectiveness percentage by calculating a first percentage of total successful testing tasks completed.
} While (Read second matrix)
End
The efficiency calculator (140) is configured to cooperate with the first matrix generator (134) and the second matrix generator (136) to calculate a first count of total number of the users and a second count of total number of the testing tasks assigned from the second matrix using a counter (142). The efficiency calculator (140) is further configured to calculate time based efficiency and overall relative efficiency based on the first count, the second count, the time taken to complete the execution of the testing tasks, and the status of completion of the testing tasks.
An exemplified pseudocode for the efficiency calculator (140) is given below:
Program (efficiency calculator)
Read first matrix, second matrix
Do
{
calculate a first count of total number of the users and a second count of total number of the testing tasks assigned from the second matrix using a counter (142); and
calculate time based efficiency and overall relative efficiency based on the first count, the second count, the time taken to complete the execution of the testing tasks, and the status of completion of the testing tasks
} While (Read first matrix, second matrix)
End
Calculation of Effectiveness
Effectiveness is computed as
Effectiveness = (# testing Tasks completed Successfully) * 100%
(Total no of testing tasks taken)
= [ Number of nij not equal to 0/(N*R)]*100%
Where,
N = Number of testing Tasks
R= Number of Users

If there are N users, and each is given T number of testing tasks,
Total number of testing tasks taken = N*T
Calculation of Efficiency

Time Based Efficiency = Goals / Sec

Overall Relative Efficiency is computed as =

nij = The result of testing task i by user j; if the user successfully completes the testing task, then it is 1, if not then it is 0
tij = The time spent by user j to complete testing task i. If the testing task is not successfully completed, then time is measured till the moment user quits the testing task.
N = Number of testing Tasks
R= Number of Users
Effectiveness and Efficiency are computed for each Persona type, separately. But overall Relative Efficiency is computed across all Persona types and category.
Effectiveness gives a measure of accuracy and completeness of user goal achievement. Typical benchmark of Effectiveness is awful, bad, average, and good.

The aesthetics assessment module (130) comprises a rating module (144), a third matrix generator (146), and an aesthetic calculator (148).
In accordance with an embodiment of the present disclosure, assessment of aesthetics is constructed through design elements and principles like visual hierarchy, balance colour, space, contrast, and the like. In one embodiment, the assessment of the aesthetics of the functionally verified refined prototype is based on Visual Aesthetics Web Inventory (VisAWI).
In an embodiment, the assessment of aesthetics of the functionally verified refined prototype is performed in the following four Categories under two dimensions, i.e.:
Visual Appeal
• Simplicity
• Colorfulness
Organization
• Diversity
• Design and Craftsmanship
The user assesses and provide rating for the functionally verified refined prototype. In another embodiment, the assessment may also be performed by an “Expert Assessor”. The Expert Assessor may assess and rate from “Technical” perspective.
The rating module (144) is configured to cooperate with the functionality verification module (112) to receive at least a first set of ratings provided for a first pre-determined set of questionnaires, stored in the repository (102), by the users for the functionally verified refined version.
An exemplified pseudocode for the rating module (144) is given below:
Program (rating)
Do
{
Receiving a first set of ratings provided for a first pre-determined set of questionnaires, stored in the repository (102), by the users for the functionally verified refined version.
} While (Read first set of ratings)
End

The third matrix generator (146) is configured to cooperate with the rating module (144) to generate a first matrix based on the first set of ratings received from each of the user.
An exemplified pseudocode for the third matrix generator (146) is given below:
Program (third matrix generator)
Read first set of ratings
Do
{
generate a first matrix based on the first set of ratings received from each of the user.
} While (Read first set of ratings)
End

The aesthetic calculator (148) is configured to cooperate with the matrix generator (146) to calculate the aesthetics by calculating a second percentage of a first average of the first set of ratings based on the first matrix.
An exemplified pseudocode for the aesthetic calculator (148) is given below:
Program (aesthetic calculator)
Read first set of ratings
Do
{
calculate the aesthetics by calculating a second percentage of a first average of the first set of ratings based on the first matrix.
} While (Read first set of ratings)
End
In an embodiment, the user and/or the expert assessor rate aesthetics assessment in the scale of 0 to 9 for a pre-determined set of questionnaires for each of the four categories, i.e., simplicity, colorfulness, diversity, and design & craftsmanship.
Visual Aesthetics Index (VAI) = (Average of all average ratings by all users /9) *100 %
Table 2 illustrates a third matrix generated based on the aforementioned aesthetics assessment.

Persona Type
User 1 User 2 User 3 User 4 User 5
Item Rating Rating Rating Rating Rating
SIMPLICITY
1 I find this website / application is easy to use s1 s2 s3 s4 s5
COLOURFULLNESS
2 The Website / App is pleasing and visually appealing c1 c2 c3 c4 c5
DIVERSITY
3 I find this Web site / App provides all the options that are required (for me) d1 d2 d3 d4 d5
DESIGN & CRAFTMANSHIP
4 The layout of the Web site is intuitive & logically organized l1 l2 l3 l4 l5
USER RATING R1 R2 R3 R4 R5

(Table 2)
The User Rating Ri = Average (si,ci,di,li)
Visual Aesthetics Index (VAI) = (Average of all User Ratings, for a Persona type, Ri / 9)*100%, wherein VAI is computed for each Persona type, separately.
The satisfaction and emotional level assessment module (132) comprises a satisfaction level calculator (150) and an emotional level calculator (152).
The satisfaction level calculator (150) is configured to cooperate with the functionality verification module (112) to receive a second set of ratings for a second pre-determined set of questions, stored in the repository (102), from each of the users, and is further configured to calculate a satisfaction level of the users by calculating a second average of the second set of ratings.
An exemplified pseudocode for the satisfaction level calculator (150) is given below:
Program (satisfaction level calculator)
Do
{
receive a second set of ratings for a second pre-determined set of questions, stored in the repository (102), from each of the users; and
calculate a satisfaction level of the users by calculating a second average of the second set of ratings.
} While (Read second set of ratings)
End
The emotional level calculator (152) is configured to cooperate with the functionality verification module (112) to receive a third set of ratings for a third pre-determined set of questions, stored in the repository (102), from each of the users, and further configured to calculate an emotional level of the users by calculating a third average of the third ratings.
An exemplified pseudocode for the emotional level calculator (152) is given below:
Program (emotional level calculator)
Do
{
receive a third set of ratings for a third pre-determined set of questions, stored in the repository (102), from each of the users;
calculate an emotional level of the users by calculating a third average of the third ratings.
} While (Read third set of ratings)
End
In an embodiment, the two set of questions may be used for computing After Scenario Question Index (ASQI) for determining satisfaction level and task load index for determining emotional level.
After Scenario Question Index (ASQI): - For example, user may be required to respond to at least three questions in scale of 0 to 9. (‘0’ as “Impossible” and ’9’ as “Extremely easy and completed”).
The three questions may be:
1. Overall, I am satisfied with the ease of completing the testing tasks in this scenario;
2. Overall, I am satisfied with the amount of time it took to complete the testing tasks in this scenario; and
3. Overall, I am satisfied with the support information (on line help, messages and documentation) when completing the testing task.
After Scenario Question Index (ASQI) = (Sum of three ratings/27) *100%
Emotional level: Task Load Index (TLI): - In an embodiment, TLI assesses mental and physical demands and stress. This is an assessment of user’s workload on working with various human-machine interface systems.
The questions for evaluation TLI includes aspects such as mental demand, physical demand, temporal demand, performance, effort and frustration.
Task Load Index (TLI) = (Sum of the ratings provided by user / 54) *100%
Table 3 illustrates a matrix generated based on ASQ.

Testing Task i
Persona type I am Satisfied with the Ease of Completing the testing Task I am satisfied with the Amount of Time it took to complete the testing task I am satisfied with the Support information/ Online Help when completed the testing task Score
User 1 s11 s12 s13 S1
User 2 s21 s22 s23 S2
User 3 s31 s32 s33 S3
User 4 s41 s42 s43 S4
User 5 s51 s52 s53 S5
(Table 3)

User Score Si = Average (si1, si2, si3)
ASQ Index ASQI = (Average Si, for a Persona / 9) * 100 %
Task Load Index which quantifies Emotional level of the user on executing the testing tasks, is computed using TLX Questions. A matrix illustrating the captured responses for TLX questions is shown in table 4 below.
Testing Task i
Persona Type = …. How mentally demanding was the testing task? How physically demanding was the testing task? How hurried/ rushed was pace of the testing task How successful were you in accomplishing what you were asked to do? How hard did you have to work to accomplish your level of performance? How insecure, discouraged, irritated, stressed & annoyed were you? Score
User 1 r11 r12 r13 r14 r15 r16 R1
User 2 r21 r22 r23 r24 r25 r26 R2
User 3 r31 r32 r33 r34 r35 r36 R3
User 4 r41 r42 r43 r44 r45 r46 R4
User 5 r51 r52 r53 r54 r55 r56 R5

(Table 4)

User Score Ri = Average (ri1, ri2, ri3, ri4, ri5, ri6)
TLI = (Average Ri, for a Persona /9) * 100%

ASQI and TLI combined provide the satisfaction level and work stress of the users, while executing the testing tasks. Higher score of both may indicate that the user is very satisfied with the functionally verified prototype and finds less/no stress/ difficulty in using the same.
In an embodiment, tool (100) may include a plurality of tracking devices for tracking brain waves to capture current emotional state of the users.
In an embodiment, three types of prototypes may be generated. Initially a low-fi prototype is generated. Further, the low-fi prototype is verified. Subsequent to testing of low-fi prototype and based on received comments thereby enabling the prototype generator 110 to construct a medium-fi prototype. Similarly, a high-fi prototype may be generated based on the measurement and verification of the medium-fi prototype.
The product development module (118) is configured to cooperate with the look and feel parameter verification module (116) to cyclize the prototype over a number of iterations, using an iterator (114), until the comments received from the input module (104) equals to zero, and is further configured to finalize the prototype to a final software product.
An exemplified pseudocode for the product development module (118) is given below:
Program (product development)
Read comments. prototype
Do
{
cyclize the prototype over a number of iterations, using an iterator (114), until the comments received from the input module (104) equals to zero; and
finalize the prototype to a final software product.
} While (Read comments, prototype)
End
The analyzer (106), digital formulator (108), prototype generator (110), functionality verification module (112), and look and feel parameter verification module (116), and product development module (118) are implemented using one or more processor(s).
The processor may be a general-purpose processor, a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), a Digital Signal Processor (DSP), and/or the like. The processor may be configured to retrieve data from and/or write data to the memory. The memory can be for example, a random access memory (RAM), a memory buffer, a hard drive, a database, an erasable programmable read only memory (EPROM), an electrically erasable programmable read only memory (EEPROM), a read only memory (ROM), a flash memory, a hard disk, a floppy disk, cloud storage, and/or so forth.
Figures 3a, 3b and 3c illustrate a flow diagram for a method of refining a crude software product. The steps include:
• Step 202: receiving, by an input module (104), comments from users testing the crude software product;
• Step 204: storing, by a repository (102), a set of pre-determined formularization rules, a list of pre-determined thresholds, and a task table having a pre-determined list of testing tasks and corresponding the users assigned to execute each of the testing task;
• Step 206: analyzing, by an analyzer (106), parsed inputted comments to generate an analysis;
• Step 208: formularizing, by a digital formulator (108), a solution based on the analysis, with the help of the formularization rules;
• Step 210: generating, by a prototype generator (110), comprising a refined version of the crude product based on the formularized solution and the formularization rules;
• Step 212: checking, by a functionality verification module (112), functionality of the prototype;
• Step 214: generating, by the functionality verification module (112), a check result based on the checking;
• Step 216: providing, by the functionality verification module (112), a failure comment to the input module (104) in case of failure of functionality of the prototype;
• Step 218: computing, by a look and feel parameter verification module (116), look and feel parameters by testing the functionally verified refined prototype based on executing the testing tasks stored in the task table and the thresholds;
• Step 220: generating, by the look and feel parameter verification module (116), a result based on the computation and provide the result to the input module (104);
• Step 222: cyclizing, by a product development module (118), the prototype over a number of iterations, using an iterator, until the comments received from the input module (104) equals to zero; and
• Step 224: finalising, by the product development module (118), the prototype to a final software product.

TECHNICAL ADVANCEMENTS
The present disclosure described herein above has several technical advantages including, but not limited to, the realization of a tool for refining a crude software product, that:
• ensures that different aspects for development of product are incorporated and verified by end users during development cycle;
• validates product to determine that the product meets customer expectation;
• quantify feedback from user experience; and
• measures the performance of product in development stage on a specific scale for guaranteeing that the needs, wants and aspirations of customers are in conformance with the product being developed.
The foregoing disclosure has been described with reference to the accompanying embodiments which do not limit the scope and ambit of the disclosure. The description provided is purely by way of example and illustration.
The embodiments herein and the various features and advantageous details thereof are explained with reference to the non-limiting embodiments in the following description. Descriptions of well-known components and processing techniques are omitted so as to not unnecessarily obscure the embodiments herein. The examples used herein are intended merely to facilitate an understanding of ways in which the embodiments herein may be practiced and to further enable those of skill in the art to practice the embodiments herein. Accordingly, the examples should not be construed as limiting the scope of the embodiments herein.
The foregoing description of the specific embodiments so fully reveal the general nature of the embodiments herein that others can, by applying current knowledge, readily modify and/or adapt for various applications such specific embodiments without departing from the generic concept, and, therefore, such adaptations and modifications should and are intended to be comprehended within the meaning and range of equivalents of the disclosed embodiments. It is to be understood that the phraseology or terminology employed herein is for the purpose of description and not of limitation. Therefore, while the embodiments herein have been described in terms of preferred embodiments, those skilled in the art will recognize that the embodiments herein can be practiced with modification within the spirit and scope of the embodiments as described herein.
Throughout this specification the word “comprise”, or variations such as “comprises” or “comprising”, will be understood to imply the inclusion of a stated element, step, or group of elements, steps, but not the exclusion of any other element, or step, or group of elements, or steps.
The use of the expression “at least” or “at least one” suggests the use of one or more elements or ingredients or quantities, as the use may be in the embodiment of the disclosure to achieve one or more of the desired objects or results.
While considerable emphasis has been placed herein on the components and component parts of the preferred embodiments, it will be appreciated that many embodiments can be made and that many changes can be made in the preferred embodiments without departing from the principles of the disclosure. These and other changes in the preferred embodiment as well as other embodiments of the disclosure will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter is to be interpreted merely as illustrative of the disclosure and not as a limitation.
,CLAIMS:WE CLAIM:

1. A tool (100) for refining a crude software product, said tool (100) comprising:
• an input module (104) configured to receive comments from users testing said crude software product;
• a repository (102) configured to store a set of pre-determined formularization rules, a list of pre-determined thresholds, and a task table having a pre-determined list of testing tasks and corresponding said users assigned to execute each of said testing task;
• an analyzer (106) configured to cooperate with said input module (104), and further configured to parse and analyses each of said inputted comments to generate an analysis;
• a digital formulator (108) configured to cooperate with said analyzer (106) and said repository (102) to formularize a solution based on said analysis, with the help of said formularization rules;
• a prototype generator (110) configured to cooperate with said repository (102) and said digital formulator (108), and further configured to generate a prototype comprising a refined version of said crude product based on said formularized solution and said formularization rules;
• a functionality verification module (112) configured to cooperate with said prototype generator (110) to receive said prototype for checking functionality of said prototype, and further configured to generate a check result based on said checking, said functionality verification module (112) further configured to provide a failure comment to said input module (104) in case of failure of functionality of said prototype;
• a look and feel parameter verification module (116) configured to cooperate with said functionality verification module (112) to receive said functionally verified refined prototype and compute look and feel parameters by testing said functionally verified refined prototype based on executing said testing tasks stored in said task table and said thresholds, and further configured to generate a result based on said computation and provide said result to said input module (104); and
• a product development module (118) configured to cooperate with said look and feel parameter verification module (116) to cyclize said prototype over a number of iterations, using an iterator (114), until said comments received from said input module (104) equals to zero, and further configured to finalize said prototype to a final software product,
wherein said analyzer (106), said digital formulator (108), said prototype generator (110), said functionality verification module (112), and said look and feel parameter verification module (116), and said product development module (118) are implemented using one or more processor(s).
2. The tool (100) as claimed in claim 1, wherein said analyzer (106) comprises:
• a parser (120) configured to cooperate with said input module (104) to parse said received comments into tokens; and
• an analyzing module (122) configured to cooperate with said parser (120) to analyses said tokens based on a set of pre-determined analysis rules stored in said repository (102).
3. The tool (100) as claimed in claim 1, wherein said look and feel parameters includes usability assessment, aesthetics assessment, and satisfaction and emotions assessment.
4. The tool (100) as claimed in claim 1, wherein said look and feel parameter verification module (116) comprises:
• a look and feel computation module (124) configured to cooperate with said functionality verification module (112) to receive said functionally verified refined prototype and compute said look and feel parameters by testing said prototype based on said task table and said thresholds; and
• a result computation module (126) configured to cooperate with said look and feel computation module (124) to generate said result based on said computation.
5. The tool (100) as claimed in claim 4, wherein said thresholds can be selected from the group consisting of time taken to complete said testing task and interaction of said users while executing said testing tasks.
6. The tool (100) as claimed in claim 4, wherein said look and feel computation module (124) comprises:
• a usability assessment module (128) configured to cooperate with said functionality verification module (112) to assess said usability of said functionally verified refined prototype;
• an aesthetics assessment module (130) configured to cooperate with said functionality verification module (112) to assess said aesthetics of said functionally verified refined prototype; and
• a satisfaction and emotional level assessment module (132) configured to cooperate with said functionality verification module (112) to assess said satisfaction and emotional level of said functionally verified refined prototype.
7. The tool (100) as claimed in claim 6, wherein said usability assessment module (128) comprises:
• a first matrix generator (134) configured to cooperate with said functionality verification module (112) to generate a first matrix based on said time taken to complete said execution of said testing tasks;
• a second matrix generator (136) configured to cooperate with said functionality verification module (112) to check a status of success or failure on completion of said testing tasks, and further configured to generate a second matrix based on said status;
• an effectiveness calculator (138) configured to cooperate with said second matrix generator (136) to generate effectiveness percentage by calculating a first percentage of total successful testing tasks completed; and
• an efficiency calculator (140) configured to cooperate with said first matrix generator (134) and said second matrix generator (136) to calculate a first count of total number of said users and a second count of total number of said testing tasks assigned from said second matrix using a counter (142), and further configured to calculate time based efficiency and overall relative efficiency based on said first count, said second count, said time taken to complete said execution of said testing tasks, and said status of completion of said testing tasks.
8. The tool (100) as claimed in claim 6, wherein said aesthetics assessment module (130) comprises:
• a rating module (144) configured to cooperate with said functionality verification module (112) to receive at least a first set of ratings provided for a first pre-determined set of questionnaires, stored in said repository (102), by said users for said functionally verified refined version;
• a third matrix generator (146) configured to cooperate with said rating module (144) to generate a first matrix based on said first set of ratings received from each of said users; and
• an aesthetic calculator (148) configured to cooperate with said matrix generator (146) to calculate said aesthetics by calculating a second percentage of a first average of said first set of ratings based on said first matrix.
9. The tool (100) as claimed in claim 6, wherein said satisfaction and emotional level assessment module (132) comprises:
• a satisfaction level calculator (150) configured to cooperate with said functionality verification module (112) to receive a second set of ratings for a second pre-determined set of questions, stored in said repository (102), from each of said users, and further configured to calculate a satisfaction level of said users by calculating a second average of said second set of ratings; and
• an emotional level calculator (152) configured to cooperate with said functionality verification module (112) to receive a third set of ratings for a third pre-determined set of questions, stored in said repository (102), from each of said users, and further configured to calculate an emotional level of said users by calculating a third average of said third ratings.

10. The tool (100) as claimed in claim 1, wherein said tool (100) may include a plurality of tracking devices for tracking brain waves to capture current emotional state of said users.
11. The tool (100) as claimed in claim 1, wherein said input module (104) can be selected from a group consisting of a gesture enabled input unit, a voice enabled input unit, a standard keyboard, a touchscreen, or any combination thereof.
12. A method for refining a crude software product, said method comprises the following steps:
• receiving (202), by an input module (104), comments from users testing said crude software product;
• storing (204), by a repository (102), a set of pre-determined formularization rules, a list of pre-determined thresholds, and a task table having a pre-determined list of testing tasks and corresponding said users assigned to execute each of said testing task;
• analyzing (206), by an analyzer (106), parsed inputted comments to generate an analysis;
• formularizing (208), by a digital formulator (108), a solution based on said analysis, with the help of said formularization rules;
• generating (210), by a prototype generator (110), comprising a refined version of said crude product based on said formularized solution and said formularization rules;
• checking (212), by a functionality verification module (112), functionality of said prototype;
• generating (214), by said functionality verification module (112), a check result based on said checking;
• providing (216), by said functionality verification module (112), a failure comment to said input module (104) in case of failure of functionality of said prototype;
• computing (218), by a look and feel parameter verification module (116), look and feel parameters by testing said functionally verified refined prototype based on executing said testing tasks stored in said task table and said thresholds;
• generating (220), by said look and feel parameter verification module (116), a result based on said computation and provide said result to said input module (104);
• cyclizing (222), by a product development module (118), said prototype over a number of iterations, using an iterator, until said comments received from said input module (104) equals to zero; and

• finalizing (224), by said product development module (118), said prototype to a final software product.