Source Code Testing: 

1. Source Code history
2. Use of readable indentation for source
3. Source Code optimization
4. Source Code Comment documentation
5. Source Code Backup
6. Appropriate naming conventions for source files
7. Appropriate storage location for source files
8. Appropriate use of Transactions wherever required
9. Appropriate use of Stored Procedures wherever required
10. Use of functions for code reuse
11. Use of Common library
12. CSS Code to be separated from the source code
13. AJAX code to be separated from the source code
14. Use of version control mechanism
15. Source Code encryption mechanism
16. Appropriate use of sessions / cookies
17. LDAP authentication
18. Following the standards. (for e.g. XHTML 1.0 standard for web coding).
19. Appropriate naming conventions for functions used and functions in the common library
20. Appropriate Folder structure for source code files
21. Clearance of extra comments, unnecessary code, echoes, alerts, type texts
22. No hard coding should be present 

Database Testing: 

1. Appropriate linking of tables
2. Normalization
3. Naming Conventions
4. Appropriate storage engine is used
5. Optimized field types are used
6. Backup function
7. Appropriate use of Triggers
8. Encrypted storage of confidential data
9. Compressed storage of big data
10. Appropriate prefixing for special characters before storage
11. Scalability
12. Database Document - Design schema with sample data
13. Appropriate filtering of data before storing into the database
14. Appropriate default values for table fields
15. Appropriate comments entered for table fields
16. Database Design query with sample data to be documented 

UI Testing: 

1. Consistency of screens
2. Consistency of background colours
3. Usage of pleasant colours
4. IPR violation with logos, images, colours, text
5. Consistency across multiple browsers (IE, Mozilla, Netscape)
6. All controls on the screen should be accessible through keyboard / Keyboard shortcuts
7. Various screen sizes testing
8. Various Platforms testing
9. Best Configuration message on home page
10. Appropriate tool tips for all elements on UI
11. All dropdowns heights and widths, symmetry and consistency
12. Textboxes height and width
13. Overall symmetry
14. All kinds of necessary validations for blank data inputs, illegal data inputs
15. Warning, error window sizes and placement
16. Test for SQL injection
17. Testing for over limit, under limit, different data types, null inputs
18. Testing for Reflection, no variable/class/method names should be hard coded
19. Print all the output reports and test them for alignment, proper page breaks, formatting, paper size, data readability and completeness
20. Scalability for various technologies, if yes, define configuration and process steps for migration
21. Backup
22. Backup Procedure documented
23. Auto/Manual Backup
24. All necessary documentations: commenting the code, flow chart, database design/schema, table design/scheme, user manual, source code/files naming conventions, ER diagram, help files, researched material
25. Testing for SOX compliancy
26. Overall user friendliness & aesthetics
27. Should be best viewable with 800x600 resolution
28. Maximizing, minimizing, resizing of windows to be possible
29. Positioning of cursor on the first editable field in Data entry screens
30. Every screen should have one Default button
31. Acknowledgment of error messages should take the control to where the error occurred
32. The Title bar should contain appropriate title
33. Every screen should have a title/header
34. Ease of use without any help
35. Grammatical correctness of error messages
36. Correct grammar for texts, field names, tool tips
37. Grammatical correctness of Help text
38. Text box lengths should correspond the length of data they take, wherever possible
39. Default values to be populated wherever possible
40. Consistent behaviour when screen resolution is changed
41. Consistency of margins and header and footer
42. Consistency of Colour of form
43. Consistency of Size of form
44. Consistency of fonts used for labels
45. Consistency of Size of buttons
46. Consistent use of animations/graphics
47. Consistency of labelling of controls (buttons, boxes)
48. Consistency of length of textboxes for the same field
49. Consistency of formats for date fields
50. Effective reuse of repeatable visual themes
51. When a button is clicked
52. When an error is encountered
53. When a field is being validated
54. Should support users' sequence of accomplishing a task
55. ‘Back' and ‘Home' links to be provided
56. Correct order of tabbing
57. Text to be selected when tabbing to a textbox
58. All tab controls should be accessible thru' keyboard
59. Shortcut keys (hot keys) to be unique
60. Links should be obvious and consistent
61. Functioning of the ‘Back' and ‘Forward' functions of the browser
62. Check if all links are active
63. Alignment of labels
64. Alignment of buttons
65. Anything that needs user action must be communicated
66. Feedback should be provided whenever relevant
67. Minimum usage of pop-ups and message boxes
68. User errors must be communicated
69. Availability of Help feature
70. Availability of Context-sensitive help, wherever needed
71. Buttons should be enabled/disabled depending on context
72. Non-editable text fields should be distinctly visible from others
73. Messages and labels should be accurate and appropriate for the context
74. Check if all links lead to meaningful points
75. Use of familiar and comfortable language
76. Abbreviations and code language to be used minimally
77. Help and Search links should be distinctly visible
78. Visible font for all text
79. Avoid all CAPS text
80. Help messages to be clear and concise
81. Error messages to be clear and concise
82. Should avoid horizontal scrolling
83. Should avoid vertical scrolling as much as possible
84. Logical ordering of controls
85. Position of controls should be meaningful
86. Grouping of related info. and data
87. Appropriate label for grouped data
88. Drop down/combo box menu to be ordered
89. Toggling of checkboxes
90. Checking/un checking of checkboxes through space-bar
91. Single choice for radio-buttons
92. Access keys (Keyboard shortcuts) letter should be underlined when visible on the UI
93. Frozen grid titles
94. Horizontal alignment of tables, body, div, span, data grid
95. Vertical alignment of tables, body, div, span, data gird
96. Mandatory fields should be distinctly marked in the UI 

Functional Testing: 

1. Basic Data flow is working properly
2. To be able to add data and save it correctly
3. To be able to edit data correctly
4. To be able to copy data correctly
5. To be able to delete data correctly
6. Cancel function
7. Logout function
8. Change Password feature
9. Password Complexity
10. Password History
11. Various authentication levels
12. Application should be accessible thru' URL as well as IP address
13. Time to load the application must be appropriate
14. Search Function
15. Search facility should be flexible (wildcards, mixed case, partial strings etc.)
16. Prompt to save unsaved data while trying to move to next screen
17. Password validation
18. Positioning of pop up windows
19. Field vs. form level validations
20. Destructive actions to be confirmed
21. UI shows navigation and user friendly message for null records in the database
22. Search Engine Optimization (SEO)
23. A "Contact us" page for maintenance team. The page should have mail id,  address and phone numbers
24. Application should have a visible status bar - logged in user, logged in time, date
25. A user confirmation while logging out or closing the application
26. User should not be allowed to navigation to any of the application pages without logging in
27. User session should auto expire within the following specified time period (5 minutes > Session Expiry time > 15 minutes)
28. Highlighting of searched keywords should be present for Search feature

JSON stands for JavaScript Object Notation. (JSON is pronounced like the name Jason)

It is a data format. (XML is also a data format)

The JSON data format is ideally suited for consumption by a JavaScript program. (In fact, JSON is JavaScript!)

WHY SHOULD I CARE ABOUT JAVASCRIPT?

Because Ajax applications use JavaScript. (And because JavaScript is very cool)

BUT AJAX APPLICATIONS CAN PROCESS DATA FORMATTED AS XML, SO WHY BOTHER WITH JSON?

If the data is formatted as XML then Ajax is limited to fetching data from the same domain (website) that the Ajax application came from.

If the data is formatted as JSON then Ajax can travel across domains. That is, Ajax can access data from anywhere. Think of the power of this: a single Ajax application, running in your browser, can reach out and grab data from an unlimited number of web services, and present it in your browser in a coherent fashion. Awesome!

WHAT DOES JSON LOOK LIKE?

Here's information about a person, his website, and his email, all structured as JSON:

{"person": {
"name": "John Doe",
"website": "http://www.example.com/",
"email": "jdoe@example.com"
}
}

HOW IS THE DATA IN JSON EXTRACTED?

Very easy: (suppose the variable "data" holds the above JSON data)

data.person.name returns "John Doe"
data.person.website returns http://www.example.com
data.person.email returns jdoe@example.com

ARE THERE WEB SERVICES THAT SERVE UP JSON?

Yes. For example, all of Yahoo's Web Services can return JSON if it's requested. Here's an example:

http://api.search.yahoo.com/NewsSearchService/V1/newsSearch?appid=xyz&query=Obama&output=json

SHOULD MY WEB SERVICE SERVE UP JSON?

I think that it would be good for your web service to be capable of serving up both XML and JSON. You might implement it in the same way Yahoo does, e.g.

http://www.example.com/web-service?output=json

http://www.example.com/web-service?output=xml

WHO DISCOVERED JSON?

JSON is the brainchild of Douglas Crockford, one of the preeminent JavaScript coders in the world today (http://www.crockford.com).

WHERE CAN I GET MORE INFO?

See the excellent book: Bulletproof Ajax, by Jeremy Keith, p. 77-87