Sunday, June 29, 2014

You Are Never Too Old To Set Another Goal Or To Dream A New Dream

Reality is something we cannot avoid or escape from. Everyday we will face a new life reality in experiences and challenges. What we receive now is come from what we have planned before, come from what we have dreamed before, come from what we prayed before.

Time will answer everything, our goal and dream suddenly become real. Real false or real right. Real expected or real unexpected.Sometimes we have to give up on our goal and dream. Not because we have not tried, we have not pushed our self, and we have not prayed. But because we cannot control everything. What we can control is ourselves, our expectations and our attitudes.

At the end, we will facing a new choices. Either to take it or leave it. Either to turn right or left. Either to move forward or turn around. We have to set another goal or to dream a new dream. Everything has its own signs to help you make choices. Don't be afraid to make up your decision. Don't let things control and drive you to something you don't want. Be your self. Your decision will determine your life.

Thank you for reading,happy Sunday and God bless you. :)

Thursday, June 26, 2014

Everything Has Beauty, But Not Everyone Sees It.

This quote was come from a big wallpaper when I was visiting a mall. It might be related with fashion or accessories. The first of the sentence is very attractive. Everything has beauty. Not only everything but everyone has beauty. God give each of us uniqueness and talents. In my perspective, most of us can reveal the strong point of ourselves. Some are not, so that's why there is a person called psychologist. For the people who have already know their identity, they should improve and maintain their beauty and strong points, meanwhile they also train their weakness.

At the end of this quote, the sentence contains a character and behavior that show respect against each other. Previously I said that most of us is not understand well about ourselves, so it's not wonder that we must respect each other. Everybody and everything has a beauty and value that we need to see. Sometimes it's very hard and we have to see from another point of view to see that beauty. It's important so we won't judge by something we cannot see completely. A wise measurement must be assessed based on only 1 point of view but whole picture of it in order to create harmony between us.

Sunday, June 22, 2014

Rahasia Untuk Kuat Mengarungi Badai Kehidupan - Dari : Pelita Hidup

“Tetapi dengan engkau Aku akan mengadakan perjanjian-Ku, dan engkau akan masuk ke dalam bahtera itu: engkau bersama-sama dengan anak-anakmu dan isterimu dan isteri anak-anakmu.” Kejadian 6:18

Hidup ini bagaikan sebuah kapal yang mengarungi samudera laut yang begitu luasnya. Ketika cuaca sedang cerah, maka kapal dapat berlayar dengan lancer tanpa gangguan. Semua perkiraan berapa lama perjalanan akan ditempuh dan rute mana yang akan dilewati dapat dilakukan dengan akurat. Bahkan kita dapat menikmati betapa indahnya perjalanan yang kita lalui hingga tujuan.

Tidak demikian ketika kita berlayar dalam keadaan cuaca yang buruk. Hujan badai yang turun akan mengakibatkan gelombang yang sangat besar, sehingga kapal akan terombang-ambing dengan begitu dahsyatnya. Ombak yang sangat besar akan membuat perjalanan menjadi sangat tidak nyaman dan juga berbahaya. Perjalanan yang ditempuh akan memakan waktu yang lebih lama dan bahkan rute perjalanan juga dapat berubah.

Kapal kecil tidak akan bertahan mengarungi samudera yang sedang diterpa oleh badai. Mungkin saja kapal tersebut dapat tenggelam oleh ganasnya badai yang menerpa. Kapal yang lebih besar dan mempunyai teknologi yang lebih canggih akan dapat bertahan mengarungi badai yang hebat. Apalagi didukung oleh nakhoda yang berpengalaman, maka kapal itu akan dapat melalui badai dengan selamat.

Demikian juga hidup kita ini, hidup kita ibarat kapal yang sedang mengarungi lautan yang luas untuk mencapai suatu tujuan. Kita tidak akan pernah tahu kapan kita melalui cuaca yang cerah dan kapan kita melalui hujan badai. Perkiraan cuaca mungkin dapat memberi kita gambaran akan apa yang akan terjadi. Tetapi kita akan tetap melewatinya apakah cuaca sedang cerah ataupun buruk.

Selama hidup kita berpegang teguh kepada Tuhan, maka Dia akan menuntun setiap langkah hidup kita. Dia akan memberi kita hikmat atas apa yang akan kita hadapi. Bahkan Dia juga akan menyertai kita dalam setiap peristiwa yang akan kita alami, entah itu baik ataupun buruk.

Untuk dapat melewati badai kehidupan yang begitu dahsyat, kita juga membutuhkan kapal yang besar dan kuat yang dapat mengarungi badai seburuk apapun. Tuhan ingin agar kita membangun bahtera kehidupan agar dapat mengarungi lautan yang luas dan bahkan melalui semua badai kehidupan yang pernah ada. Bangunlah bahtera kehidupan kita dengan membina keintiman dengan Tuhan. Berdoa senantiasa kepadaNya, baca FirmanNya setiap hari dan lakukan apa yang menjadi perintahNya, dengan demikian kita membangun bahtera kita untuk siap mengarungi lautan kehidupan. Semakin rutin kita membangun keintiman dengan Tuhan, semakin kuat bahtera kehidupan yang kita bangun.

Jadikanlah Yesus sebagai nahkoda kehidupan kita, biarlah Dia yang menuntun arah langkah hidup kita. Melalui setiap Firman yang kita baca, maka Tuhan akan memperdengarkan suaraNya. Dan setiap Firman yang kita dengar merupakan hikmat yang Dia berikan bagi kita untuk menuntun hari-hari kita. Biarkan Tuhan yang membawa kita mengarungi lautan untuk mencapai tujuan.

Bina keintiman dengan Tuhan agar kita dapat senantiasa berada di dalam bahtera kehidupan dan jadikan Yesus sebagai nahkoda hidup kita, sehingga kita dapat melalui berbagai macam masalah yang ada. Haleluya!

Sumber : Pelita Hidup

Thursday, June 19, 2014

7 Things to Do When You Have to Give a Short Speech

You can find a lot of advice on how to give a big speech in front of a big audience. But more often, you're probably asked to take just a few minutes to address a smaller group. Here's how to give a short speech that will leave your audience wanting more.

I once went to a small fundraising event for a nonprofit that I thought the world of. They did so much good in my neighborhood that I truly thought they could do no wrong.

Then one of the organizers asked someone to stand up "to say a few words," and her presentation turned into one of the longest, least organized, most lifeless talks I've ever heard. Those who were lucky enough to be standing near the back of the room slipped out. For the rest of us, the goodwill seemed to slip away.

You can find a lot of advice out there on how to give a big speech on front of a big audience--but how often do most of us do that? More often, you're likely asked to take a few minutes to address a smaller group--sometimes with little or no warning. The next time that happens to you, here are seven things to keep in mind.

1. Strip it down.

There's an unfortunate temptation in a short speech to try to cram everything you have to say into a short time. Instead of trying to make the time fit the speech, however, recognize that you have to make your remarks fit the time allotted. If you've got five minutes to talk, you shouldn't have more than three main points.

Key: If your short speech is longer than this article, it's too long.

2. Plan and rehearse.

This applies whether you have five days notice before your speech or 30 seconds. If you're surprised to be called on to speak, your planning might consist only of conjuring up your three main points while someone else is trying to get everyone's attention and introduce you, but that's better than nothing. Ideally, you want to plan everything you're going to say, rehearse in front of other people, and rewrite over and over.

Key: Don't fall into the trap of thinking that short remarks require less preparation. In fact, giving a good short speech can be harder than giving a long one.

3. Cut yourself off.

In the history of the entire world, I don't think anyone has ever said, "I wish that speech had been longer." So keep track of time, and by all means don't ramble. If you've run out of time to make a major point, either work it into the questions people have for you afterward, or send a follow-up note to the members of the audience.

Key: Take the length of time you've been asked to speak for, and cut it down by 20 percent.

4. Use milestones

For a five minute speech, you want to organize in roughly one-minute intervals, and you want to offer milestones to the audience at the top of each minute. You get one minute for your introduction, during which you explain what you plan to say. Then you get 60 seconds each for your three main points. That last 60 seconds can be used either for a short conclusion, or as a buffer in case you run long.

Key: Use verbal cues to keep the audience on track. Phrases that seem obvious on the written page can be much more helpful in oral remarks: "That was the first point. Now we'll talk about the second of my three points."

5. Show. Don't tell.

For a short speech, I generally like to have something physical to show the audience--a couple of photos, a prop, anything that gives the audience's eyes something to focus on. Think of the difference between announcing, "Yesterday, we signed an important deal," versus holding up a ballpoint pen and saying, "With this pen, we made history yesterday when we signed Spacely Sprockets to a five-year contract." (Or else, raise your coffee cup and proposing a toast, rather than just making an announcement.) It can be a little bit corny, granted, but it's much more memorable.

Key: If you use props, you almost always want to use them early in your remarks. Don't distract the audience and have them wondering what the projector is for, or why you are holding a teddy bear or a vacuum cleaner (or whatever your prop may be).

6. Make it personal

You do not need to bare your soul, but in almost every short speech there is an opportunity to connect on a personal level with your audience. Don't be afraid to allow emotion to enter into your voice if appropriate. If the news is good, say you're happy and proud; if you have to share something sad or infuriating, make your tone and your expressions match the news.

Key: A few short words can be enough to make a connection. Simply saying with sincerity something like, "On a personal note, I'm so incredibly proud of this group" or "I can't tell you yet how we will overcome this challenge, but I can tell you for damn sure we will find a way"--depending on the circumstance--can be enough.

7. Speak up.

All of your preparation, cutting, organizing, and emotion goes for naught if people can't hear you. If you have good audio equipment, use it. If not, at least start out by asking whether people can hear your voice. One trick: Ask the audience to raise their hands if they can hear you well. If you see a patch of people somewhere without their hands up, you know there's an issue you need to address.

Key: Remember that ensuring everyone can hear is your responsibility. Project your voice, and if you find that people in the back can't hear what you have to say consider moving to the center. If you run into trouble and can't find a solution, cut your remarks short, and find a way to follow up later.

Source: Bill Murphy JR - Via Inc.Com

Monday, June 9, 2014

Selection Criteria For ETL Tools - From ETLTool.Com

Below ETLTool have listed some of the criteria ETLTool examined. In the first place ETLTool asked some basic questions about the company. In the middle of the page there are several links you can click on to select information about the more technical criteria like architecture, scalability, maintainability, functionality, usability and so forth.

At the end, important information like version number, type, price indications, etc. The criteria for success are explained in more detail in the full ETL Tools & Data Integration Survey 2014.

#Company & Market
  • Entry into the market (year): In which year was the product released for the first time?
  • Customers world wide: The number of customers worldwide.
  • Installations world wide: The number of installations worldwide. For code generators the number of developer seat. 
#Architecture - Parallel processing
  • Symmetric Multiprocessing (SMP): Is Symmetric Multiprocessing supported? Standard in Windows NT and UNIX. The processors in SMP systems share their internal and external memory.
  • Massively parallel processing (MPP): Every processor in a MPP system has its own internal and external memory and database, allowing high performance to be achieved. These databases should be synchronized.
  • Cluster Aware: Is the ETL server ‘cluster aware’ and does it support load balancing, fail-over and other cluster facilities?
  • Grid: Can an ETL process run on a ‘grid’ of computers or servers?
  • Job distribution: Is it possible to run ETL processes on different machines or processors?
  • Data pipelining: Can the different steps of an ETL process be run on different machines or processors?
  • Partitioning: Is it possible to partition based on, for example, product codes, to determine on which machine or processor the data has to be processed?
  • Basic architecture: h = hub & spoke (all data runs through one point), d = distributed (multiple lines between sources and targets) and m = multi hub/spoke
  • End-to-end BI infrastructure: Does the ETL tool exchange metadata, for example star schemas, with OLAP or reporting tools, from their own range of products or third parties products
  • Supports CWM: Is the ETL tool CWM-compliant, in other words does it support the Common Warehouse Meta Model?
  • Version control system: Does the product contain a version control system with check-in and check-out features?
#ETL Functionality
  • Splitting data streams/multiple targets: Is it possible to read a data source once and load the results into two or more tables?
  • Conditional splitting: The same, but then in a conditionally, for example, if revenue is higher than 1000 put the results in table 1 otherwise in table 2
  • Union: Put rows of different tables with the same structure into one table or dataset
  • Pivoting: Is it possible to transform denormalised data, putting data in the column names, into rows
  • Depivoting: The other way around, transform (highly) normalised data to de-normalised data, putting data in the columns
  • Key lookups in memory: Can you load a table completely into internal memory and search the table? (without having to make joins)
  • Key lookups reusable across processes: Are these tables reusable across different loading processes in such a way the key lookup table is loaded once into memory?
  • Read non-structured data: Can the product read non structured data like text, email, video etc and if so which file types
  • Slowly changing dimensions: Does the tool support slowly changing dimensions (hm = manually; wizard = wizard; auto = out-of-the-box)
  • Scheduler: Is there a mature scheduler that supports dependencies?
  • Error handling within job: Can errors be detected within the job, and is it possible to change the route within the process flow when a specific error arises?
  • Impact analysis: Is it possible to make an impact analysis of proposed changes (when an attribute or table must change)
  • Data lineage: Can one track down easily the source of an attribute/information-element (reversed impact analysis)
  • Automatic documentation: Can you publish and document a process/transformation automatically and navigate through it with a browser?
  • Support for data mining models: Is it possible during the loading process to make use of the results of a data mining process?
  • Support for analytical functions: During the loading process, is it possible to invoke different kinds of analytical functions like forecasting, basket analysis, regression?
  • Ease-of-use: The ease-of-use of the product. Is it easy to learn and easy to use on a daily basis?
  • WYSIWYG: Is the principle ‘What You See Is What You Get’ applied to the DATA?
  • Screen design: Is the screen design ergonomic and well-balanced?
  • Task compatibility ETL / EAI: Does the tool support the tasks (in the same sequence) as the ETL developer?
  • Training Requirement: What is the recommended training both for the developer and the end user
  • Completeness of the GUI: What percentage of the functionality can be generated directly from the GUI
  • Training requirements: both for the professional developer and the business user (where appropriate)
  • Reusability of components: Are components reusable and can they handle parameters (this is not the same as copy-paste)?
  • Decomposition: Can processes be divided into named small pieces of building blocks (modular programming)?
  • User-defined functions: Is it possible to define user-defined functions and to use them in the process flow?
  • Comments on selection of objects: Can one make comments on a selection of objects in such a way that these comments are tightly connected
  • Step-by-step running: Can you run the process flow step-by-step?
  • Row-by-row running: Can you run the process flow row-by-row?
  • Breakpoints: Can you set a breakpoint on a particular process step or a row of data?
  • Watch Points: Can you define watch points, so the system postpone running when a certain condition is met?
  • Compiler/validater: Is it possible to validate the process flow (and/or code) with one click of the mouse and are errors reported and marked?
  • Integration batch – real-time: Is it possible to define within the ETL tool process flows moving and transforming data in real-time and in batch?
  • Mechanism: How are changes in the source systems detected and put through (mq = message queuing; logging = database logs or journals; trigger = database triggers)?
  • On-demand data integration: Can you publish an ETL process and/or target attribute as a Web Service?
  • Native connections: How much and which native connections does the ETL tool support? (ODBC, OLE DB and flat files excluded)
  • Packages / enterprise applications: How many packages / enterprise applications can the tool read meta data from with one click of the mouse (for example SAP, Siebel, Peoplesoft, JD Edwards, Baan)
  • Real-time connections: How many and which type of message queuing products can the tool connect to?
  • Support for joined tables as source: Can you join two tables in a graphical manner letting the database execute the join as opposed to letting the ETL tool join the tables
  • Changed data capture: Does the ETL tool support the principle of Changed Data Capture (select only the changes (deltas) from the database)
  • Built-in functions for data quality: Are there functions available to control the quality of the data (for example a matching transformation or an address cleanser) # fuzzy logic
  • Built-in functions for data validation: Does the tool have functions for data validation like ‘delete duplicates’, ‘missing values’, ‘incorrect data’) # 100% match
  • Data profiling: Options for data profiling, uniqueness of values, maximum, minimum, distribution of values, and so on.
#General ETL Tool characteristics
  • Platforms: The number of platforms the ETL tool runs on
  • Version: The version number of the product that has been evaluated
  • Engine-based / code generator: Is the tool Engine-based or an Code-generator (eg = engine based; cg = code generator)
  • Type: ‘Process’ when the user can define an unlimited number of tasks/steps between source and target else ‘Map’


Source : ETLTool.Com

Saturday, June 7, 2014

Difference Between UAT and SIT - 7 Challenges of UAT

#Rajeev Prabhakaran Nair

User acceptance Testing is performed by the Client of the application to determine whether the application is developed as per the requirements specified by him/her. It is performed within the development of the organization or at the client site. Alpha testing and Beta testing are the examples of Acceptance Testing.

System testing is performed by the Testers to determine whether the application is satisfying the requirements as specified in SRS. (System Requirement Specification)

#Peter the 'One'

System integration testing is testing performed when two systems, generally presumed stable themselves, are integrated with one another. For example, this could be when an inventory management system is integrated with a sales accounting system. Each system feeds into the other.

The goal of systems integration testing is to ensure that the data crossing the boundary between systems is received, stored and used appropriately by the receiving system. Until integration begins, testing of the isolated systems is done on mocked or replayed data and not on "live" data. Integration testing is the final step before customer acceptance testing.

What is User Acceptance Testing?

User Acceptance Testing is often the final step before rolling out the application.

Usually the end users who will be using the applications test the application before ‘accepting’ the application.

This type of testing gives the end users the confidence that the application being delivered to them meets their requirements.

This testing also helps nail bugs related to usability of the application.

User Acceptance Testing – Prerequisites:

Before the User Acceptance testing can be done the application is fully developed.
Various levels of testing (Unit, Integration and System) are already completed before User Acceptance Testing is done. As various levels of testing have been completed most of the technical bugs have already been fixed before UAT.

User Acceptance Testing – What to Test?

To ensure an effective User Acceptance Testing Test cases are created.
These Test cases can be created using various use cases identified during the Requirements definition stage.
The Test cases ensure proper coverage of all the scenarios during testing.

During this type of testing the specific focus is the exact real world usage of the application. The Testing is done in an environment that simulates the production environment.
The Test cases are written using real world scenarios for the application

User Acceptance Testing – How to Test?

The user acceptance testing is usually a black box type of testing. In other words, the focus is on the functionality and the usability of the application rather than the technical aspects. It is generally assumed that the application would have already undergone Unit, Integration and System Level Testing.

However, it is useful if the User acceptance Testing is carried out in an environment that closely resembles the real world or production environment.

The steps taken for User Acceptance Testing typically involve one or more of the following:

  1. User Acceptance Test (UAT) Planning
  2. Designing UA Test Cases
  3. Selecting a Team that would execute the (UAT) Test Cases
  4. Executing Test Cases
  5. Documenting the Defects found during UAT
  6. Resolving the issues/Bug Fixing
  7. Sign Off 

#Software Testing Help

What is User Acceptance Testing (UAT)?
UAT is final testing performed when functional, system and regression testing is completed. The main purpose of UAT is to validate the software against the business requirements. This validation is carried out by end users who are familiar with the business requirements. UAT, alpha and beta testing are different types of acceptance testing.

As user acceptance testing is the last testing carried out before the software goes live, obviously this is the last chance for the customer to test the software and measure if it’s fit for the purpose.

Need of User Acceptance Testing
Developers and functional testers are technical people who validate the software against the functional specifications. They interpret the requirements according to their knowledge and develop/test the software (here is the importance of domain knowledge). This software is complete according to the functional specifications but there are some business requirements and processes which are known to end users only are either missed to communicate or misinterpreted. UAT plays an important role in validating if all the business requirements are fulfilled or not before releasing software for the market use. Use of live data and real use cases make UAT testing an important part of the release cycle.

Many businesses who suffered big losses due to post-release issues know the importance of successful UAT. The cost of fixing defects after release is many times greater than fixing it before.

Who should be part of the UAT team?
Mainly end users of the software should be involved in UAT. The team can be comprised of beta testers or customer should select UAT members internally from every group of organization so that each and every user role can be tested.

7 Major Challenges of UAT And Mitigation Plan To Overcome These

It doesn’t matter if you are part of a billion dollar release or a startup team, you should overcome these UAT challenges for delivering successful software for the end user.

1) UAT environment setup and deployment process
Carrying out UAT on same environment used by functional test team will certainly end up overlooking real world use cases. Also crucial testing activities like performance testing can’t be carried out on test environment with incomplete test data. Separate production like environment should be setup for UAT.

Once the UAT environment is separated from test environment you need to control the release cycle effectively. Uncontrolled release cycle may leads to different software versions on test and UAT environment. Valuable UAT time is wasted by not testing software on latest version. Not to mention the time required for issue tracking on incorrect software version.

2) UAT test planning
UAT should be planned with clear acceptance test plan in requirement analysis and design phase. In strategy planning, set of real world use cases should be identified for execution. It is very important to define test objectives for UAT testing as complete test execution for large application is not possible in UAT phase. Testing should be carried out by prioritizing critical business objectives first.

UAT is carried out at the end of the testing cycle. Obviously it is the most critical period for the software release. Delay in any of the previous stages of development and testing eat up UAT time. Improper test planning, in worst cases, leads to overlap between system testing and UAT. Due to less time for UAT and pressure to meet deadlines, software is deployed to UAT environment even though functional testing is not completed. UAT goals can’t be achieved in such situations.

UAT test plan (template) should be prepared and communicated to team well before beginning UAT. This will help them for test planning, writing test cases and test scripts and creating UAT environment.

3) Handling new business requirements as incidents/defects
Ambiguities in requirements get caught in UAT phase. UAT testers find issues arising due to ambiguous requirements (by looking at the complete UI which wasn’t available during requirement gathering phase) and log it as a defect. Customer expects these to be fixed in current release without considering the time for change requests. If timely decision is not taken by project management on these last-minute changes this could lead to the release failure.

4) Unskilled testers or testers without business knowledge
If there is no permanent UAT test team, company select UAT staff from various internal departments. Even if this staff is well familiar with business needs, if they are not trained for the new requirements being developed they can’t perform effective UAT. Also non-technical business team might face many technical difficulties executing UAT test cases. Also assigning testers at the end of the UAT cycle do not add any value to the project. Little time to train UAT staff can significantly increase the chances of UAT success.

5) Improper Communication channel

Communication between remote development, testing and UAT team is more difficult. Email communication is often very difficult when you have an offshore tech team. A small ambiguity in incident reports can delay its fix for a day. Proper planning and effective communication are critical to effective team collaboration. Project teams should use web based tool to log defects and questions. This will help to distribute work load evenly and avoid reporting duplicate issues.

6) Asking functional test team to perform UAT
There is no worse situation than asking functional test team to perform UAT. Customers offload their responsibility to test team due to lack of resources. The whole purpose of UAT gets compromised in such cases. Once the software goes live, end users will quickly spot the issues which are not considered as real world scenarios by functional testers. Solution to this is to assign UAT to dedicated and skilled testers having business knowledge.

7) The blame game
Sometimes business users just try to find reasons to reject the software. It might be their selfdom to show how superior they are or blame the development and testing team to get respect in business team. This is very rare but happens in teams with internal politics. It’s very difficult to deal with such situations. Building positive relationship with business team would definitely help to avoid blame game.

Friday, June 6, 2014

Overview of UAT ( User Acceptance Testing )


User acceptance testing (UAT) consists of a process of verifying that a solution works for the user. It is not system testing (ensuring software does not crash and meets documented requirements), but rather is there to ensure that the solution will work for the user i.e. test the user accepts the solution (software vendors often refer to as Beta testing).

This testing should be undertaken by a subject-matter expert (SME), preferably the owner or client of the solution under test, and provide a summary of the findings for confirmation to proceed after trial or review. In software development, UAT as one of the final stages of a project often occurs before a client or customer accepts the new system. Users of the system perform tests in line with what would occur in real life scenarios.

The UAT acts as a final verification of the required business functionality and proper functioning of the system, emulating real-world usage conditions on behalf of the paying client or a specific large customer. If the software works as required and without issues during normal use, one can reasonably extrapolate the same level of stability in production.


User acceptance testing (UAT) is the last phase of the software testing process. During UAT, actual software users test the software to make sure it can handle required tasks in real-world scenarios, according to specifications.

UAT is one of the final and critical software project procedures that must occur before newly developed software is rolled out to the market.

UAT is also known as beta testing, application testing or end user testing.

UAT directly involves the intended users of the software. UAT can be implemented by making software available for a free beta trial on the Internet or through an in-house testing team comprised of actual software users.

Following are the steps involved in in-house UAT:

  • Planning: The UAT strategy is outlined during the planning step.
  • Designing test cases: Test cases are designed to cover all the functional scenarios of the software in real-world usage. They are designed in a simple language and manner to make the test process easier for the testers.
  • Selection of testing team: The testing team is comprised of real world end-users.
  • Executing test cases and documenting: The testing team executes the designed test cases. Sometimes it also executes some relevant random tests. All bugs are logged in a testing document with relevant comments.
  • Bug fixing: Responding to the bugs found by the testing team, the software development team makes final adjustments to the code to make the software bug-free.
  • Sign-off: When all bugs have been fixed, the testing team indicates acceptance of the software application. This shows that the application meets user requirements and is ready to be rolled out in the market.
UAT is important because it helps demonstrate that required business functions are operating in a manner suited to real-world circumstances and usage.

#Develop Mentor

User Acceptance Testing (UAT) is one sure way to reduce or eliminate change requests, and drastically reduce project costs. 

Testing accomplishes a variety of things, but most importantly it measures the quality of the application. Testing presupposes there are defects in the software waiting to be discovered and this view is rarely disproved or even disputed. Several factors contribute to the importance of making UAT testing a high priority of any software development effort; these include:
  • Reducing the cost of developing the application. Minimal savings that might occur in the early stages of the development cycle by delaying testing efforts are almost certainly bound to increase development costs later.
  • Ensuring that the application behaves exactly as expected. For the vast majority of programs, unpredictability is the least desirable consequence of using an application.
  • Reducing the total cost of ownership. By providing software that looks and behaves as shown in your documentation, your customers require fewer hours of training and less support from product experts.
  • Developing loyalty and word-of-mouth market share. Finding success with a program that offers the kind of quality that only thorough testing can provide is much easier than trying to build a customer base on buggy and defect-riddled code.
What is User Acceptance Testing?
User Acceptance Testing (UAT) - also called beta testing, application testing, and/or end user testing - is a phase of software development in which the software is tested in the "real world" by the intended audience or a business representative. Whilst the technical testing of IT systems is a highly professional and exhaustive process, testing of business functionality is an entirely different proposition.

The Goal of UAT Testing
If you ask somebody the question “What is the goal of a software test?'' you might get an answer like: “The goal is to prove that a system does what it is supposed to do''. This answer is not exactly correct and demonstrates the necessity to define some fundamentals about software testing. Another response would be, “The goal is to find faults or defects''.

The goal of User Acceptance Testing is to assess if the system can support day-to-day business and user scenarios and ensure the system is sufficient and correct for business usage.

Where does Testing Fit In?
When a software developer writes code, it is common for mistakes to occur, such that requirements are not adequately implemented or they are forgotten. It is during this process that errors are introduced into the system. It is also possible that the business had not communicated their requirements correctly, or they could have insufficient details, which could result in a system working as designed, but not as expected.

UAT tests are created to verify the system’s behavior is consistent with the requirements. These tests will reveal defects within the system. The work associated with UAT begins after requirements are written and continues through the final stage of testing before the client/user accepts the new system.

The “V” Model for Testing
The “V” model is a methodology where development and testing takes place at the same time with the same kind of information available to both teams. It is good practice to write the UAT test plan immediately after the requirements have been finalized.

The "V" model shows development phases on the left hand side and testing phases on the right hand side.

Why is Testing Important?
Most of us have had an experience with software that did not work as expected. Software that doesn’t work can have a large impact on an organization, and it can lead to many problems including:

  • Loss of money – this can include losing customers right through to financial penalties for non-compliance to legal requirements
  • Loss of time – this can be caused by transactions taking a long time to process but can include staff not being able to work due to a fault or failure
  • Damage to business reputation – if an organization is unable to provide service to their customers due to software problems then the customers will lose confidence or faith in this organization (and probably take their business elsewhere)
It is important to test the system to ensure it is error free and that it supports the business that depends on it.  The later problems are discovered the more costly they are to fix.

The later problems are discovered the more costly they are to fix.

Some Common Testing Problems
If you make a list of some of the most common test problems, you will realize that in many cases the majority of problems are nontechnical.  More often than not, they are consequences of the test process itself, including the overall composition of the test team and whether the company follows well-integrated processes for formal requirements handling and change management. The results indicate the huge discrepancy in the level of importance that different organizations give to testing. Some of these problems are more common to younger organizations; others are pitfalls that anyone can encounter.

The Cost Multiplier
An informal survey of the relative cost of finding defects throughout the software development lifecycle was conducted several years ago. It was found that a problem that goes undetected and unfixed until an application is actually in operation can be 40 – 100 times more expensive to resolve than resolving the problem early in the development cycle.

In traditional testing methodologies, most defects are discovered late in the software development process. Finding and fixing these defects cost much more than if they had been found earlier. Another survey of the relative cost of testing software compared with the overall cost of developing software gives a range of estimates, from 10% in smaller organizations to 70% in some larger and mature organizations.

Lessons Learned/Best Practices
In order to avoid mistakes that may impact the process, cost, and quality of the software testing phase, it is a good idea for testers to get involved with the project as early as possible and consider the following:

  • Focus testing on requirements
  • Poorly written requirements account for the majority of project failures, so it is important to have the testers involved with the review and test plan creation at the beginning of the project
  • Design systems for testability
  • Systems should be designed and coded with testing in mind. Testers should emphasize the importance of error logs, interfaces and smaller, standalone components which can greatly improve the testability of a system once testers become involved
  • Consider usability testing
  • One of the most overlooked requirements is “usability”. Testers should promote the importance of ease of use and schedule usability tests as early as possible
Traits of a Good UAT Tester
A UAT Tester is one of the most important testing roles since they are validating the system meets the business needs. UAT is usually the final activity before the system goes “live” and this role requires multi-faceted skills. These qualities allow the person playing that role to perform this important activity. Without these qualities one may not be able to conduct a proper UAT test. These four core qualities of a UAT Tester are:

  • Background: Experience of user operations, Not involved in the overall IT project, Experience in the use of IT facilities, and respected as an independent thinker
  • Skill: A good communicator, avoids politics, Expects the system to fail
  • Independence: Not involved in user specifications, Has an independent reporting structure, and is a self starter
  • Attitude: Lateral thinker, tenacious, analytical
The Role, Activities, and Deliverables of the Business Analyst during UAT
Business Analysts make good UAT testers because they are independent from the developers; therefore arguably more objective. In most cases they also understand the business requirements, and can prepare test scenarios and test data, which are realistic. This allows them to better define the context in which the system will be used and better assess its fit for purpose. Finally Business Analysts have a vested interest in ensuring the system is of high quality so are motivated to perform rigorous testing.

Tasks of User Acceptance Testing
When performing UAT, there are seven (7) basic steps to ensure the system is tested thoroughly and meets the business needs.

  1. Analyze Business Requirements
  2. Identify UAT Scenarios
  3. Define the UAT Test Plan
  4. Create UAT Test Cases
  5. Run the Tests
  6. Record the Results
  7. Confirm Business Objectives are met
Documents Used by the Business Analyst
One of the most important activities performed by the Business Analyst is to identify and develop UAT test scenarios. These scenarios are derived by analyzing the documents that were previously developed during the early phases of the project. These documents include:

  • Business Use Case
  • Business Process Flows
  • Project Charter
  • Context Diagram
  • Business Requirements Document (BRD)
  • System Requirements Specification (SRS)
  • Testing Guidelines and Techniques
  • Other Vendor’s Deliverables
Documents Created by the Business Analyst
Once UAT Test Scenarios are identified, the Business Process Unit will create three deliverables:

  • UAT Test Plan
  • UAT Test Cases
  • After running the tests, a Defect Log captures problems
What is a UAT Test Plan?
The UAT Test Plan documents the strategy that will be used to verify and ensure an application meets its requirements to the business. The UAT Test Plan is a document which outlines the plan for user acceptance testing of the project deliverables. This document is a high level guide, and will refer to test cases that will be developed and used to record the results of user testing.

What are UAT Test Cases?
The User Acceptance Test Cases help the test execution team to test the application thoroughly. This also helps ensure that the UA testing provides sufficient coverage of all the UAT scenarios. The Use Cases created during the Requirements definition phase may be used as inputs for creating test cases.

The User Acceptance Test Case describes in a simple language the precise steps to be taken to test something

What is a UAT Defect Log?
The UAT Defect Logis a document for capturing and reporting defects identified during UAT. Defects are documented so that they can be evaluated and resolved.
Information included in the Defect Log is:

  • Severity (e.g., High, Med, Low)
  • Status (e.g., Open, Closed, Deferred)
  • Date Reported/Fixed
  • Problem Description

Thursday, June 5, 2014

Overview of SIT ( System Integration Testing )


In the context of software systems and software engineering, system integration testing (SIT) is a testing process that exercises a software system's coexistence with others. With multiple integrated systems, assuming that each have already passed system testing, SIT proceeds to test their required interactions. Following this, the deliverables are passed on to acceptance testing.

SIT is part of the software testing life cycle for collaborative projects. Usually, a round of SIT precedes the user acceptance test (UAT) round. Software providers usually run a pre-SIT round of tests before consumers run their SIT test cases.

For example, if an integrator (company) is providing an enhancement to a customer's existing solution, then they integrate the new application layer and the new database layer with the customer's existing application and database layers. After the integration is complete, users use both the new part (extended part) and old part (pre-existing part) of the integrated application to update data. A process should exist to exchange data imports and exports between the two data layers. This data exchange process should keep both systems up-to-date. The purpose of system integration testing is to ensure all parts of these systems successfully co-exist and exchange data where necessary.

There may be more parties in the integration, for example the primary customer (consumer) can have their own customers; there may be also multiple providers.

Data driven method
A simple method of SIT which can be performed with minimum usage of software testing tools. Data imports and exports are exchanged before the behavior of each data field within each individual layer is investigated. After the software collaboration, there are three main states of data flow.

--Data state within the integration layer
Integration layer can be a middleware or web service(s) which acts as a medium for data imports and data exports. Data imports and exports performance can be checked with the following steps.
  1. Cross checking of the data properties within the Integration layer with technical/business specification documents.
    • For web service involvement with the integration layer, WSDL and XSD can be used against web service request for the cross check.
    • Middleware involvement with the integration layer allows for data mappings against middleware logs for the cross check.
  2. Execute some unit tests. Cross check the data mappings (data positions, declarations) and requests (character length, data types) with technical specifications.
  3. Investigate the server logs/middleware logs for troubleshooting.
(Reading knowledge of WSDL, XSD, DTD, XML, and EDI might be required for this)

Data state within the database layer
  1. First check whether all the data have committed to the database layer from the integration layer.
  2. Then check the data properties with the table and column properties with relevant to technical/business specification documents.
  3. Check the data validations/constrains with business specification documents.
  4. If there are any processing data within the database layer then check Stored Procedures with relevant specifications.
  5. Investigate the server logs for troubleshooting.
(Knowledge in SQL and reading knowledge in [stored procedures] might be required for this)

Data state within the Application layer
There is not that much to do with the application layer when we perform a system integration testing.
  1. Mark all the fields from business requirement documents which should be visible in the UI.
  2. Create a data map from database fields to application fields and check whether necessary fields are visible in UI.
  3. Check data properties by some positive and negative test cases.
There are many combinations of data imports and export which we can perform by considering the time period for system integration testing

(We have to select best combinations to perform with the limited time). And also we have to repeat some of the above steps in order to test those combinations.


System integration testing (SIT) is a high-level software testing process in which testers verify that all related systems maintain data integrity and can operate in coordination with other systems in the same environment. The testing process ensures that all subcomponents are integrated successfully to provide expected results.

IT validates data integrity between the different sub-components that make up a specified system. The SIT process occurs after unit testing and before validation testing. Due to the fact that SIT concentrates on testing the dependencies between sub-components, it is often subjected to regression testing scenarios. Regression testing facilitates the addition of new test cases. From an application perspective, SIT testing focuses on access to actual data passed through the components and initial connectivity.

The main goal of SIT testing is to test the automation of aggregated components and the dependencies that exist between them. In a complex environment, this is a tedious task, as there are a number of components and dependencies. SIT testing ensures that it follows the dependencies available in a sequence, thereby simplifying the task. After system integration is performed, data flow testing takes place through three states, namely the data states within the integration, database and application layers.

Test cases for SIT testing are developed using test design techniques such as:

  • Use case testing
  • State transition testing
  • Load testing
  • Usability testing
  • Volume testing
  • Graph-based testing
  • Decision table testing