Important principles of agile projects

spunk

trust to solve problems tomorrow once they appear tomorrow. Feel free to come up with your concerns about actual problems today on a constructive way - do it before somebody else does it.

communication

arrange face2face meetings - project members which meet they feel more comfortable to work together. Any problem is important to solve - communication problems are most important to solve.

feedback

force acceptance tests of your target clients, make reviews with other team members to receive feedback's about possible better solutions.

simple

search for the simplest solution to solve your problem - exactly to solve upcoming problem. For 5 different problems think about 5 simple solutions instead one very complex solution. next time you know enough about the problem to solve all them together in one very simple solution.

Lists.GetListItems Method (Lists) - only 100 items returned

An application I'm developing against Sharepoint 2007 (MOSS) is reading from provided WebService data from a list.

http://YourURI.COM/Data/_vti_bin/Lists.asmx

Since the application is growing we get more and more items within lists.

The Method I uses were:
public XmlNode GetListItems ( string listName, string viewName, XmlNode query, XmlNode viewFields, string rowLimit, XmlNode queryOptions, string webID);

I do not add any rowLimit (null) but I were able to handel this over lists defaults.

• navigate to sharepoint
• select your list
• list settings
• All Items below Views
• manipulate Item Limit to an approperiate amount

Once I done above steps i got all my 102 entries from the list.

Windows Shortcut's - i'm loving it!

Windows Shortcut's are available from "Start->Run" and then you enter your requested shortcut.

Accessibility Controls: access.cpl
Add Hardware Wizard: hdwwiz.cpl
Add/Remove Programs: appwiz.cpl
Administrative Tools: control.exe admintools
Automatic Updates: wuaucpl.cpl
Bluetooth Transfer Wizard: fsquirt
Calculator: calc
Certificate Manager: certmgr.msc
Character Map: charmap
Check Disk Utility: chkdsk
Clipboard Viewer: clipbrd
Command Prompt: cmd
Component Services: dcomcnfg
Computer Management: compmgmt.msc
Date and Time Properties: timedate.cpl
DDE Shares: ddeshare
Device Manager: devmgmt.msc
Direct X Control Panel (if installed): directx.cpl
Direct X Troubleshooter: dxdiag
Disk Cleanup Utility: cleanmgr
Disk Defragment: dfrg.msc
Disk Management: diskmgmt.msc
Disk Partition Manager: diskpart
Display Properties: control.exe desktop
Display Properties: desk.cpl
Display Properties (w/Appearance Tab Preselected): control.exe color
Dr. Watson System Troubleshooting Utility: drwtsn32
Driver Verifier Utility: verifier
Event Viewer: eventvwr.msc
File Signature Verification Tool: sigverif
Findfast: findfast.cpl
Folders Properties: control.exe folders
Fonts: control.exe fonts
Fonts Folder: fonts
Free Cell Card Game: freecell
Game Controllers: joy.cpl
Group Policy Editor (XP Prof): gpedit.msc
Hearts Card Game: mshearts
Iexpress Wizard: iexpress
Indexing Service: ciadv.msc
Internet Properties: inetcpl.cpl
Java Control Panel (if installed): jpicpl32.cpl
Java Control Panel (if installed): javaws
Keyboard Properties: control.exe keyboard
Local Security Settings: secpol.msc
Local Users and Groups: lusrmgr.msc
Logs You Out Of Windows: logoff
Mcft Chat: winchat
Minesweeper Game: winmine
Mouse Properties: control.exe mouse
Mouse Properties: main.cpl
Network Connections: control.exe netconnections
Network Connections: ncpa.cpl
Network Setup Wizard: netsetup.cpl
Nview Desktop Manager (if installed): nvtuicpl.cpl
Object Packager: packager
ODBC Data Source Administrator: odbccp32.cpl
On Screen Keyboard: osk
Opens AC3 Filter (if installed): ac3filter.cpl
Password Properties: password.cpl
Performance Monitor: perfmon.msc
Performance Monitor: perfmon
Phone and Modem Options: telephon.cpl
Power Configuration: powercfg.cpl
Printers and Faxes: control.exe printers
Printers Folder: printers
Private Character Editor: eudcedit
Quicktime (If Installed): QuickTime.cpl
Regional Settings: intl.cpl
Registry Editor: regedit
Registry Editor: regedit32
Removable Storage: ntmsmgr.msc
Removable Storage Operator Requests: ntmsoprq.msc
Resultant Set of Policy: rsop.msc
Resultant Set of Policy (XP Prof): rsop.msc
Scanners and Cameras: sticpl.cpl
Scheduled Tasks: control.exe schedtasks
Security Center: wscui.cpl
Services: services.msc
Shared Folders: fsmgmt.msc
Shuts Down Windows: shutdown
Sounds and Audio: mmsys.cpl
Spider Solitare Card Game: spider
SQL Client Configuration: cliconfg
System Configuration Editor: sysedit
System Configuration Utility: msconfig
System File Checker Utility: sfc
System Properties: sysdm.cpl
Task Manager: taskmgr
Telnet Client: telnet
User Account Management: nusrmgr.cpl
Utility Manager: utilman
Windows Firewall: firewall.cpl
Windows Magnifier: magnify
Windows Management Infrastructure: wmimgmt.msc
Windows System Security Tool: syskey
Windows Update Launches: wupdmgr
Windows XP Tour Wizard: tourstart
Wordpad: write

shortcuts have been copied from the following location: http://khanusah.blogspot.com/2008/07/run-mmc-command.html

Improve Web Application Performance

Introduction

In the IT world, software applications are being rapidly developed. Clients, and so employers, are just looking for those teams/individuals who can build up applications rapidly, just bothering to make their application live; but what often happens after an application goes live is that users start to use the application and it doesn’t respond well. At this point, clients start to lose users and business.To code an application is not a big deal; I believe it can be done by virtually anyone, meaning it is not necessary to have great knowledge or experience. Improving performance of an existing application (especially an one put together rapidly) could be quite risky and could cause many ripple effects. Things must be planned first to avoid horrible results.The following are a few points that can make a site scalable and reliable; but which may initially slow down development. I believe that overall, when maintenance and future changes are taken into account, total development time would be reduced.

1. Minimize HTTP based Requests
2. HTTP Compression:
3. Correct Formatted Images at the Right Place:
4. Compress CSS, JavaScript and Images
5. CSS at Top
6. Javascript at Bottom
7. Content Delivery Network: (CDN)
8. Ajax
9. Ajax vs. Callback
10. Reduce Cookie size
11. Use Cache appropriately
12. Upload compiled code rather than source code

Following are few good practices to gain better performance:

• For HTTP compression, GZip is considered the most effective and most popular by means of browsers and HTTP server. It can reduce file size up to 70% in size.
• Always keep JavaScript and CSS in external files.
• Avoid redirects until needed. Server.Transfer is also provided so consider that as well since it performs better in some conditions.
• Minimize use of Iframes as it's costly.
• Avoid try-catch blocks for control-flow as they perform poorly. Exceptions should be used only in truly exceptional situations.
• Minimize Cookie/CSS sizes.
• Minimize DOM objects on page as they are heavy weight.
• Use link tags rather than @import to use/link up CSS.
• Favicon, being a static image displayed in the browser’s address bar, should be cacheable and compressed.
• Always prefer a cache-friendly folder structure. For example, create specific folders for static contents, like /static for static images/static pages.
• SSL can never be cached so minimize its usage. Keep it for those pages which need to be secure, rather than using it for all the pages.
• HTTP Post requests can’t be cached, so choose the HTTP method appropriately.
• Prevent Denial of Service (Dos) attacks.
• Prevent SQL Injection.
• Prevent Cross Site Scripting (XSS).

Read the full article by dr.honey (IT SURGEON) at the following link: http://developerscon.blogspot.com/2008/06/improve-web-application-performance.html

Understanding Object Pooling in Microsoft .NET

Joydip Kanjilal has published a very intersting object pooling article.

Introduction
Object Pooling is nothing new. It is a concept that implies that we can store a pool of objects in memory to be reused later and, hence, reduce the load of object creation to a great extent. An Object Pool, also known as a Resource Pool, is a list/set of ready to be used reusable objects that reduce the overhead of creating each object from the scratch whenever a request for an object creation comes in. This is somewhat similar to the functioning of a Connection Pool, but with some distinct differences. This article throws light on this concept (Object Pooling) and discusses how we can implement a simple generic Object Pool in .NET.

What is an Object Pool?
An Object Pool may be defined as a container of objects that are ready for use. Lists of ready-to-be-used objects are contained in this pool. Whenever a new request for an object creation comes in, the request is served by allocating an object from the pool. Therefore, it reduces the overhead of creating and re-creating objects each time an object creation is required. "An object pool is an object that holds a list of other objects, ready to make them available for use (to yet another object, probably). It does the management work involved, like keeping track of which objects are currently in use, how many objects the pool holds, whether this number should be increased."

Why is an Object Pool required?
The biggest advantage of using Object Pooling is that it minimizes the consumption of memory and the system's resources by recycling and re-using objects as and when it is needed and serving the request for new objects from the pool of ready-to-be-used objects. The objects that the application is done with (the objects are no longer needed) are sent back to the pool rather than destroying them from the memory. According to MSDN, "Once an application is up and running, memory utilization is affected by the number and size of objects the system requires. Object pooling reduces the number of allocations, and therefore the number of garbage collections, required by an application. Pooling is quite simple: an object is reused instead of allowing it to be reclaimed by the garbage collector. Objects are stored in some type of list or array called the pool, and handed out to the client on request. This is especially useful when an instance of an object is repeatedly used, or if the object has an expensive initialization aspect to its construction such that it's better to reuse an existing instance than to dispose of an existing one and to create a completely new one from scratch."

read the full article at the following link: http://www.dotnetjohn.com/articles.aspx?articleid=252