.NET Stuff for Geeks. Use that brain...

Influencer Book Trailer

2012-02-15T11:12:00.000-08:00

Tomando el Training =)

Basic trouble-shooting list :)

2008-09-15T10:05:00.000-07:00

1. check the event log
2. google it
3. reboot
4. run iisreset
5. empty the recycle bin
6. hit ctrl+break
7. kill the aspnet worker process
8. clear temporary internet files
9. touch the config file
10. degauss the monitor
11. remove everything from the startup folder
12. "get latest" and rebuild
13. login as admin
14. run ipconfig /renew
15. check if capslock is on.
16. run a virus scan
17. download the latest CTP
18. disable and then re-enable the network interface
19. restart services (some/most/all)
20. change your password
21. unplug your router, and leave it unplugged for 10 seconds before plugging it back in
22. clear your cookies
23. add current site to your trusted zone
24. disable javascript
25. try to ping the server
26. press 'clean solution' from the context menu in the solution explorer
27. repair the installation
28. run large magnets over all hard drives
29. check the network cable
30. defrag the hard drive
31. try it in a different browser
32. run a spyware scan
33. minimize all windows and check for a modal dialog
34. ensure configuration is correct
35. see what has changed recently
36. run process monitor
37. run chkdsk /v
38. revert all checkins from anyone named 'Gazza'
39. run the windows update service
40. remove and then recreate all Bluetooth partnerships
41. do a hardware reset on your mobile device
42. decompile + monkey punch + duck slap + donkey whack
43. what would jesus do?
44. look for suitable workarounds
45. re-calibrate your Geiger counter
46. check for packet storms
47. best to rule out toxicological contamination early on
48. describe the problem in terms even a child can understand
49. apply duct tape
50. increase the timeout duration
51. increase the maximum threadpool size
52. write to your local minister or government representative
53. try using the Microsoft Online Crash Analysis to submit your crash dump bucket-id
54. disable the customer experience improvement program
55. eat liver of sacred monkey
56. import the decryption certificate to the local client certificate store
57. ensure sql server is setup for mixed mode authentication
58. bypass proxy server for local addresses
59. check the hosts file and the routing tables
60. use filemon to locate any other log files being accessed
61. check the bios
62. update the device drivers for all peripherals
63. attach a debugger, get a memory dump, look at it in a hex reader and post it to a forum
64. cleanse all user inputs
65. put a try catch around it
66. replace the batteries in your wireless mouse and keyboard
67. recompile all dll's
68. uninstall the old version, re- install the new version, apply hot fixes patches and upgrades
69. remove the case from your computer, and aim a fan at it
70. check that you haven't been blacklisted
71. run diagnostic checks on surge protection units
72. add an index
73. remove an index
74. recalculate indexes
75. ensure ftp uses passive mode
76. recalculate statistics
77. reboot in safe mode
78. check kerberos delegation
79. review query plan
80. if 'automatically detect settings' is checked/unchecked, then uncheck/check it
81. kill rogue processes in task manager
82. run memtest.exe
83. boot from your emergency repair disks
84. follow standard knoppix data recovery procedures
85. tweak-UI
86. uninstall adobe pdf reader
87. insert "Debug.WriteLine("up to line 53");" where appropriate
88. set tracelevel to verbose
89. flush buffers
90. % truss -t \!all -t open a.out
91. use cdb or windbg. add in SOS for clr issues.
92. field test any lightning protection devices
93. use a temperature gauge on all hardware components, and compare against safe operating limits from manufacturer
94. run it inside a VM
95. check the DPI.
96. search the knowledge base
97. enable javascript debugging
98. turn off friendly http error messages in IE
99. set the current culture to en-US
100. attach a multi-meter
101. roll back to your most recent backup
102. check for GC pressure
103. empty the MSI cache
104. temporarily allow popups
105. look in your spam folder
106. recompile. wait. recompile.
107. turn off windows firewall
108. run caspol and give everything full trust
109. put yourself in the shoes of the program itself. if you were the program, what would you do?
110. ask hanselman
111. try wireshark. failing that, try fiddler. what does tracert show?
112. check the blueprints and read over the uml.
113. implement the retry pattern.
114. rtfm
115. delete the bios
116. attach anti-static wrist strap on every appendage
117. it inside a faraday cage
118. insert "alert('here');" where appropriate
119. overwrite every byte in memory the standard five times as pre-scribed by nsa guidelines
120. reinstall the operating system from the original media provided by the supplier
121. add a lock statement
122. blame Irwin the intern
123. blame the guy who left last week
124. blame the ESL guy
125. blame DNS
126. add a sleep statement
127. apply a fudge factor.
128. run a spell checker over your code
129. light some candles. sacrifice chicken.
130. set all DWORD's to 0 in the registry. Then delete the registry
131. drop all databases.
132. unregister and re-register all dlls
133. reboot 3 times
134. drink own urine
135. run prime95 overnight
136. recompile the kernel
137. do the packets hop subdomains, and if so does NAS require a NAS forwarding service -- how about VLAN?
138. track down the original programmers who wrote the system, apply percussive trauma therapy.
139. uninstall java
140. underclock it
141. ignore it
142. post a request for comment on theDailyWTF
143. ask for correlating evidence that the problem even exists
144. sharpen your wooden stakes before proceeding any further
145. melt silver crucifixes onto tips of all bullets
146. fill your water bottle with holy water
147. call tech support
148. check when daylight savings begins
149. simmer ground rhino horn on a bed of whale pancreas
150. plan and enact your fire evacuation plan
151. bathe in holy water
152. increase dosage on all medications. check for interactions.
153. bury heart of an ox at midnight under crossroads on fullmoon
154. clean up your desk
155. check that pump's suction pipe is elevated above bottom of pond. (Float the inlet 18 to 24 inches below the water surface)
156. wear shoes with six inch cork soles
157. wear raincoat, goggles, breathing apparatus
158. climb into an anti static bag
159. always use a condom
160. check pressure reading on gauges number 1 and 2
161. run it through an oscilloscope
162. check your immunization schedule is up to date
163. check for seismic/tectonic activity, solar flares, tsunami, meteor showers.
164. go and get a coffee. come back and look at it with a fresh set of eyes.

Close Vs Dispose - Eternal discussion

2008-09-02T16:02:00.000-07:00

If we compare to connection object, Dispose will also clear the connection, whereas Close will not. This means that if you close a connection and then open it, it will work OK, but if you dispose it and then open it, it will throw InvalidOperationException since the connection string is not initialized

I would always argue that you should call Dispose() on any object that implements IDisposable (as Microsoft Recomend) when you are through with the object. Even if it does nothing. The jit compiiler will optimize it out of the final code anyway(Because of finalizer thread who do the task). If the object contains a Close() but no Dispose() then call Close().

IL of the Dispose method of Connection Object

.method family hidebysig virtual instance void Dispose(bool disposing) cil managed
{
.maxstack 2
L_0000: ldarg.1
L_0001: brfalse.s L_0017
L_0003: ldarg.0
L_0004: ldnull
L_0005: stfld class System.Data.Common.DbConnectionOptions System.Data.SqlClient.SqlConnection::_userConnectionOptions
L_000a: ldarg.0
L_000b: ldnull
L_000c: stfld class System.Data.ProviderBase.DbConnectionPoolGroup System.Data.SqlClient.SqlConnection::_poolGroup
L_0011: ldarg.0
L_0012: callvirt instance void System.Data.Common.DbConnection::Close()
L_0017: ldarg.0
L_0018: ldarg.1
L_0019: call instance void System.Data.SqlClient.SqlConnection::DisposeMe(bool)
L_001e: ldarg.0
L_001f: ldarg.1
L_0020: call instance void [System]System.ComponentModel.Component::Dispose(bool)
L_0025: ret
}

Dispose of Connection Object (C#):

protected override void Dispose(bool disposing)
{
if (disposing)
{
this._userConnectionOptions = null; (make connection string = null)
this._poolGroup = null; (Remove connection from connection pool)
this.Close(); (Close connection)
}
this.DisposeMe(disposing); (Dispose Connection)
base.Dispose(disposing); (Dispose parent object)
}

_userConnectionOptions is effectively the processed connection string as theprovider uses it internally

A Recurrent question: Should I initialize las member (fields) and no member variables?

2008-09-02T15:55:00.000-07:00

NO Never

Explicitly initializing class member variables and method variables actually reduces performance in .NET.
This article explores the different types of variable initialization schemes available in .NET and the performance impact of each initialization scheme. Measurements indicate that expressly initializing variables slows object initialization by 10% and slows method calls by about 20%.

In .NET, the Common Language Runtime (CLR) expressly initializes all variables as soon as they are created. Value types are initialized to 0 and reference types are initialized to null. When you expressly initialize your variables, the compiler creates code to set the value of the variables and includes that code as part of your object initialization (for classes) or method call (for methods).
The compiler is not smart enough (Microsoft, take a hint…) to discover this duplicate initialization. Granted, if you initialize a variable to a non-default value (e.g., int A = 3;) the compiler is perfectly justified in creating the extra code. When you instantiate an object (using the new keyword) or make a method call, the following sequence happens:

1. Your variables are allocated (based on instructions from the compiler).
2. The variables are initialized by the CLR.
3. The code for the object constructor or method is executed.

The problem here is: if you explicitly initialized your variables, the constructor or method code will initialize your variables again. Is this really a problem? In many cases, the double initialization is not a problem:
If the variables are static (class variables), the initialization is done once during the entire life of the process. If the class is instantiated only a few times or the method is rarely called, the extra initialization time can be safely ignored.

- But what about those objects instantiated many times in rapid succession?
- What about those methods called thousands of times?
- What is the performance impact?

Using Visual Studio .NET 2003 in "Release" mode (with the optimizer using default settings) and running on my Win2K 1.6GHz Pentium-M machine:

Creating an object and not initializing variables ~503mSec (100%)
Creating an object and initializing on definition ~557mSec (111%)
Creating an object and initializing in the constructor ~582mSec (116%)
Calling a method and not initializing local variables ~253mSec (100%)
Calling a method and initializing variables ~316mSec (125%)

Conclusions:

- If an object is heavily used (created many times a second) – don’t initialize the variables. Not initializing shaves a nice 10% off the initialization. Obviously, if you do time-consuming and lengthy initialization in the constructor – the variable initialization time will become insignificant and lost in the noise.
- For short and quick methods which are heavily used – avoid initializing local variables to default values – just trust the CLR to do it for you.

Surprisingly, initializing variables in the constructor is a little slower than initializing on definition but this may be explained by the fact that class B has an empty constructor so the constructor calling code might be eliminated by the optimizer, saving a little time.

source: http://www.codeproject.com/KB/dotnet/DontInitializeVariables.aspx

Dispose Pattern

2008-07-01T09:16:00.000-07:00

C# Sample

public sealed class MyClass: IDisposable{
// Variable to track if Dispose has been called
private bool disposed = false;
// Implement the IDisposable.Dispose() method
public void Dispose(){
// Check if Dispose has already been called
if (!disposed) {
// Call the overridden Dispose method that contains common cleanup code
// Pass true to indicate that it is called from Dispose
Dispose(true);
// Prevent subsequent finalization of this object. This is not needed
// because managed and unmanaged resources have been explicitly released GC.SuppressFinalize(this);
}
}

// Implement a finalizer by using destructor style syntax
~MyClass() {
// Call the overridden Dispose method that contains common cleanup code
// Pass false to indicate the it is not called from Dispose
Dispose(false);
} // Implement the override Dispose method that will contain common
// cleanup functionality protected virtual void Dispose(bool disposing){ if(disposing){
// Dispose time code . . . }
// Finalize time code . . . }
…}

Passing true to the protected Dispose method ensures that dispose specific code is called. Passing false skips the Dispose specific code. The Dispose(bool) method can be called directly by your class or indirectly by the client.
If you reference any static variables or methods in your finalize-time Dispose code, make sure you check the Environment.HasShutdownStarted property. If your object is thread safe, be sure to take whatever locks are necessary for cleanup.
Use the HasShutdownStarted property in an object's Dispose method to determine whether the CLR is shutting down or the application domain is unloading. If that is the case, you cannot reliably access any object that has a finalization method and is referenced by a static field

protected virtual void Dispose(bool disposing){ if(disposing){ // dispose-time code . . . } // finalize-time code CloseHandle(); if(!Environment.HasShutDownStarted) { //Debug.Write or Trace.Write – static methods Debug.WriteLine("Finalizer Called"); } disposed = true;}

Visual Basic .NET sample

'Visual Basic .NET Code snippet

Public Class MyDispose
Implements IDisposable

Public Overloads Sub Dispose()
Implements IDisposable.Dispose
Dispose(True)
GC.SuppressFinalize(Me) ' No need call finalizer
End Sub

Protected Overridable Overloads Sub Dispose(ByVal disposing As Boolean)

If disposing Then
'Free managed resources

End If

' Free unmanaged resources

End Sub

Protected Overrides Sub Finalize()
Dispose(False)
End SubEnd Class

Common disposable resources include the following:

Database-related classes: SqlConnection, SqlDataReader, and SqlTransaction.
File-based classes: FileStream and BinaryWriter.
Stream-based classes: StreamReader, TextReader, TextWriter, BinaryReader, and TextWriter.
Network-based classes: Socket, UdpClient, and TcpClient.
EnterpriseServices: classes that derive from System.EnterpriseServices.ServicedComponent

TOOLS for Preventing SQL Injection

2008-06-25T08:42:00.000-07:00

Code Review

2008-01-30T05:34:00.000-08:00

I usually need to have information like this at hand. This is the compilation of techniques to improve General Performance in manage code. This information belong to Microsoft Patterns and Practices and can be found in the MSDN Library. It’s good to know that every Pattern and Practices have its correspondent Checklist which is super useful to verify quickly what we have not checked yet.

http://msdn.microsoft.com/practices/topics/perfscale/default.aspx?pull=/library/en-us/dnpag/html/scalenet.asp

Design Considerations:

Design for efficient resource management.
Reduce boundary crossings.
Prefer single large assemblies rather than multiple smaller assemblies.
Factor code by logical layers.
Treat threads as a shared resource.
Design for efficient exception management.

Class Design Considerations:

Do not make classes thread safe by default.
Consider using the sealed keyword.
Consider the tradeoffs of using virtual members.
Consider using overloaded methods.
Consider overriding the Equals method for value types.
Know the cost of accessing a property.
Consider private versus public member variables.
Limit the use of volatile fields.

Garbage Collection Guidelines

Identify and analyze your application's allocation profile.
Avoid calling GC.Collect.
Consider weak references with cached data.
Prevent the promotion of short-lived objects.
Set unneeded member variables to Null before making long-running calls.
Minimize hidden allocations.
Avoid or minimize complex object graphs.
Avoid preallocating and chunking memory.
Finalize and Dispose Call Close or Dispose on objects that support it.
Use the using statement in Microsoft® C# and Try/Finally blocks in Microsoft Visual Basic®.NET to ensure Dispose is called.
Do not implement Finalize unless required.
Implement Finalize only if you hold unmanaged resources across client calls.
Move the finalization burden to the leaves of object graphs.
If you implement Finalize, implement IDisposable.
If you implement Finalize and Dispose, use the Dispose pattern.
Suppress finalization in your Dispose method.
Allow Dispose to be called multiple times.
Call Dispose on base classes and on IDisposable members.
Keep finalizer code simple to prevent blocking.
Provide thread-safe cleanup code only if your type is thread-safe.
Pinning
If you need to pin buffers, allocate them at startup.

Threading

Minimize thread creation.
Use the thread pool when you need threads.
Use a Timer to schedule periodic tasks.
Consider parallel versus synchronous tasks.
Do not use Thread.Abort to terminate other threads.
Do not use Thread.Suspend and Thread.
Resume to pause threads.
Asynchronous Calls
Consider client-side asynchronous calls for UI responsiveness.
Use asynchronous methods on the server for I/O bound operations.
Avoid asynchronous calls that do not add parallelism.

Locking and Synchronization

Determine if you need synchronization.
Determine the approach.
Determine the scope of your approach.
Acquire locks late and release them early.
Avoid locking and synchronization unless required.
Use granular locks to reduce contention.
Avoid excessive fine-grained locks.
Avoid making thread safety the default for your type.
Use the fine grained lock (C#) statement instead of Synchronized.
Avoid locking "this".
Coordinate multiple readers and single writers by using ReaderWriterLock instead of lock.
Do not lock the type of the objects to provide synchronized access.

Boxing and Unboxing

Avoid frequent boxing and unboxing overhead.
Measure boxing overhead. Use DirectCast in your Visual Basic .NET code.

Exception Management

Do not use exceptions to control application flow.
Use validation code to avoid unnecessary exceptions.
Use the finally block to ensure resources are released.
Replace Visual Basic .NET On Error Goto code with exception handling.
Do not catch exceptions that you cannot handle.
Be aware that rethrowing is expensive.
Preserve as much diagnostic information as possible in your exception handlers.
Use performance monitor to monitor common language runtime (CLR) exceptions.

Iterating and Looping

Avoid repetitive field or property access.
Optimize or avoid expensive operations within loops.
Copy frequently called code into the loop.
Consider replacing recursion with looping.
Use for instead of foreach in performance-critical code paths.

String Operations

Avoid inefficient string concatenation.
Use + when the number of appends is known.
Use StringBuilder when the number of appends is unknown.
Treat StringBuilder as an accumulator.
Use the overloaded Compare method for case-insensitive string comparisons.

Arrays

Prefer arrays to collections unless you need functionality.
Use strongly typed arrays.
Use jagged arrays instead of multidimensional arrays.

Collections

Analyze your requirements before choosing the collection type.
Initialize collections to the right size when you can.
Consider enumerating overhead.
Prefer to implement IEnumerable with optimistic concurrency. Consider boxing overhead. Consider for instead of foreach.
Implement strongly typed collections to prevent casting overhead.

Reflection and Late Binding

Prefer early binding and explicit types rather than reflection.
Avoid late binding. Avoid using System.
Object in performance critical code paths.
Enable Option Explicit and Option Strict in Visual Basic.NET.

Code Access Security

Consider SuppressUnmanagedCodeSecurity for performance-critical, trusted scenarios.
Prefer declarative demands rather than imperative demands.
Consider using link demands rather than full demands for performance - critical, trusted scenarios.

Working Set Considerations

Load only the assemblies you need.
Consider assemblies that are being loaded as side effects.
Reduce the number of application domains, and/or make assemblies shared assemblies.
Reduce the number of threads.

Native Image Generator (Ngen.exe)

Scenarios where startup time is paramount should consider Ngen.exe for their startup path. Scenarios that will benefit from the ability to share assemblies should adopt Ngen.exe.
Scenarios with limited or no sharing should not use Ngen.exe.
Do not use Ngen.exe for ASP.NET version 1.0 and 1.1. Consider Ngen.exe for ASP.NET version 2.0. Measure performance with and without Ngen.exe.
Regenerate your image when you ship new versions.
Choose an appropriate base address. Install assemblies in the GAC if you want to use NGEN to get the best performance.
A setup application for an update of a library assembly should run the 'Ngen.exe update' command.

Common Performance Myths

2007-11-05T14:01:00.000-08:00

Common Performance Myths

1 One of the most common myths is that C# code is faster than Visual Basic code. There is a grain of truth in this, as it is possible to take several performance-hindering actions in Visual Basic that are not possible to accomplish in C#, such as not explicitly declaring types. But if good programming practices are followed, there is no reason why Visual Basic and C# code cannot execute with nearly identical performance. To put it more succinctly, similar code produces similar results.

2 Another myth is that codebehind is faster than inline, which is absolutely false. It doesn't matter where your code for your ASP.NET application lives, whether in a codebehind file or inline with the ASP.NET page. Sometimes I prefer to use inline code as changes don't incur the same update costs as codebehind. For example, with codebehind you have to update the entire codebehind DLL, which can be a scary proposition.

3 Myth number three is that components are faster than pages. This was true in Classic ASP when compiled COM servers were much faster than VBScript. With ASP.NET, however, both pages and components are classes. Whether your code is inline in a page, within a codebehind, or in a separate component makes little performance difference. Organizationally, it is better to group functionality logically this way, but again it makes no difference with regard to performance.

4 The final myth I want to dispel is that every functionality that you want to occur between two apps should be implemented as a Web service. Web services should be used to connect disparate systems or to provide remote access to system functionality or behaviors. They should not be used internally to connect two similar systems. While easy to use, there are much better alternatives. The worst thing you can do is use Web services for communicating between ASP and ASP.NET applications running on the same server, which I've witnessed all too frequently.

Web Client Software Factory

2007-10-24T14:10:00.000-07:00

Web Client Software Factory - Release June 2007

Architects and developers can use the Web Client Software Factory to quickly incorporate many of the proven practices and patterns of building Web client applications. These practices and patterns have been identified during the development of many Web client applications and their components.
By using the software factory, architects and developers can focus their efforts on business opportunities and create Web applications that effectively address the needs of their organizations.
The Web Client Software Factory provides an integrated set of guidance that assists architects and developers in creating composite Web applications and page flow client applications.
These applications have one or more of the following characteristics:

They have complex page flows and workflows.
They are developed by multiple collaborating development teams.
They are composite applications that present information from multiple sources through an integrated user interface.
They support XCopy deployment of independently developed modules.
They support online business transaction processing Web sites.

This software factory provides proven solutions to common challenges found while building and operating large transaction processing enterprise Web sites. It helps architects and developers build modular systems that can be built by independent teams, design complex screen workflows, improved security and testability.

Applications built with the software factory use proven practices for operations like centralized exception logging and can be XCopy deployed.

The software factory contains a collection of reusable components and libraries, Visual Studio 2005 solution templates, wizards and extensions, How-to topics, automated tests, extensive architecture documentation, patterns, and a reference implementation. The software factory uses ASP.NET, Windows Workflow Foundation, and the Enterprise Library–January 2006.

Software Factory Contents

The Web Client Software Factory is an integrated collection of tailored software assets that support composite Web application development. The collection includes the following:

Application blocks and libraries. The Composite Web Application Block, Page Flow Application Block, ObjectContainerDataSourceControl control are included in the software factory. The software factory also uses Enterprise Library application blocks for security, exception management, logging, and data access.

Recipes. The software factory includes the Add View (with presenter) recipe and Add Page Flow recipe. Recipes automate procedures in How-to topics, either entirely or selected steps. They help developers complete routine tasks with minimal input.

Templates. The software factory includes the Solution template, Business Module template, Foundational Module template, and Page Flow template. Templates are prefabricated application elements with placeholders for concrete arguments. They can be used for many purposes, including creating initial solution structures to creating individual solution artifacts, such as project items.

Designers. The software factory includes the page flow designer. Designers provide information that architects and developers can use to model applications at a higher level of abstraction. Designers can also generate code that is compatible with the architecture baseline.
Reference implementation. The software factory includes the Global Bank Corporate e-Banking reference implementation. A reference implementation provides an example of a realistic, finished product that the software factory helps developers build.

Architecture guidance and patterns. The software factory includes architecture guidance and patterns that help explain application design choices and the motivation for those choices.

How-to topics. The software factory includes How-to topics; these are documented step-by-step instructions that describe how to implement recommended practices in a specific domain.

Premier Field Engineer .NET

2007-06-25T09:02:00.000-07:00

I just wanted to post the profile of the Microsoft Premier Field Engineer (PFE) because after month and a half of an interviews ...now I'm one of them. For my surprise I recently discover that there are only 930 PFE in the entire world, 560 in the Americas and only 2 in Venezuela. One is PFE in Active Directory and one is PFE in .Net me!, so that means a lot for me. It is not going to be easy and Tons of work is comming.

God is giving me a total new experience and I'm expecting very big blessings in this stage of my career.

Premier Field Engineer .NET

The purpose of the Premier Field Engineer (PFE) position is to provide Microsoft customers with reliable technical solutions to the complex integration problems associated with business solutions built on the Microsoft platform. The PFE Team supports a diverse variety of technical solutions built with Microsoft technology and products.

Typical tasks performed in this role include specific problem isolation and correction, user mode debugging, conducting application design and supportability reviews, performance tuning, application stability consulting/troubleshooting, code reviews, and porting/migration assistance, configuration management, pre-rollout testing and general development consulting. The prospective PFE candidate should draw upon all resources at Microsoft, to advise and consult on the use of Microsoft technologies to avoid such problems in the future.

The PFE position requires a long list of technology experience or demonstrated understanding of these technologies.

Technical requirements:

Superior problem solving and troubleshooting skills at a systems engineer level
Solid knowledge and experience with the Microsoft Windows platform and .NET Framework
The ideal PFE skill set is grounded in a solid understanding of the Microsoft Windows platform. From this foundation, the PFE position is exposed to many technologies, including but not limited to: .Net Framework 3.0, .Net Framework 2.0, ASP.Net, BizTalk Server, IIS, SQL Server, Microsoft Office SharePoint Server, and Commerce Server 2000, B2C and B2B applications, development with .NET languages, C#, VB.Net, C/C++, XML and scripting, COM/DCOM/COM+, MSMQ, data access technologies, transaction processing, networking.
Practical Win 32 user or kernel mode debugging and managed code debugging are preferred skills.

Qualifications Include:

Candidates must have exceptional customer service, problem solving, and communication skills, and the ability to work in a team environment.
Must have sufficient technical depth to communicate with development and other internal organizations at a peer level as well as convey technical concepts to non-technical individuals.
Must possess the ability to work with minimal supervision and operate as a self contained business unit within the PFE team.
Must have the ability to work independently and as part of a team.
Must demonstrate the aptitude for providing exceptional customer service in politically charged environments.
Ability to enhance the technical expertise or peers via training, development and delivery , mentoring of new hires, and team content development.
Demonstrate strategic thinking with value-add contributions.
Strong business background in Fortune 500 and/or experience with systems technology consulting firm desired.

Overnight travel is required. Travel requirements vary regionally and could be as much as 40-70%. Candidates must possess current passport or be able to obtain passport within 90 days of hire. They must be available for travel dispatch 24x7x365.

BS in Computer Science or equivalent experience required. MCSD, MCAD, or other applicable advanced certification is strongly preferred, but not required at hire; however, must be obtained within 12 months of hire.

Well I like that description!!

Designing the Components of an Application or Service

2007-05-17T11:32:00.000-07:00

User interface (UI) components. Most solutions need to provide a way for users to interact with the application. In the retail application example, a Web site lets customers view products and submit orders, and an application based on the Microsoft Windows® operating system lets sales representatives enter order data for customers who have telephoned the company. User interfaces are implemented using Windows Forms, Microsoft ASP.NET pages, controls, or any other technology you use to render and format data for users and to acquire and validate data coming in from them.

User process components. In many cases, a user interaction with the system follows a predictable process. For example, in the retail application you could implement a procedure for viewing product data that has the user select a category from a list of available product categories and then select an individual product in the chosen category to view its details. Similarly, when the user makes a purchase, the interaction follows a predictable process of gathering data from the user, in which the user first supplies details of the products to be purchased, then provides payment details, and then enters delivery details. To help synchronize and orchestrate these user interactions, it can be useful to drive the process using separate user process components. This way the process flow and state management logic is not hard-coded in the user interface elements themselves, and the same basic user interaction "engine" can be reused by multiple user interfaces.

Business workflows. After the required data is collected by a user process, the data can be used to perform a business process. For example, after the product, payment, and delivery details are submitted to the retail application, the process of taking payment and arranging delivery can begin. Many business processes involve multiple steps that must be performed in the correct order and orchestrated. For example, the retail system would need to calculate the total value of the order, validate the credit card details, process the credit card payment, and arrange delivery of the goods. This process could take an indeterminate amount of time to complete, so the required tasks and the data required to perform them would have to be managed. Business workflows define and coordinate long-running, multi-step business processes, and they can be implemented using business process management tools such as BizTalk Server Orchestration.

Business components. Regardless of whether a business process consists of a single step or an orchestrated workflow, your application will probably require components that implement business rules and perform business tasks. For example, in the retail application, you would need to implement the functionality that calculates the total price of the goods ordered and adds the appropriate delivery charge. Business components implement the business logic of the application.

Service agents. When a business component needs to use functionality provided in an external service, you may need to provide some code to manage the semantics of communicating with that particular service. For example, the business components of the retail application described earlier could use a service agent to manage communication with the credit card authorization service, and use a second service agent to handle conversations with the courier service. Service agents isolate the idiosyncrasies of calling diverse services from your application, and can provide additional services, such as basic mapping between the format of the data exposed by the service and the format your application requires.

Service interfaces. To expose business logic as a service, you must create service interfaces that support the communication contracts (message-based communication, formats, protocols, security, exceptions, and so on) its different consumers require. For example, the credit card authorization service must expose a service interface that describes the functionality offered by the service and the required communication semantics for calling it. Service interfaces are sometimes referred to as business facades.

Data access logic components. Most applications and services will need to access a data store at some point during a business process. For example, the retail application needs to retrieve product data from a database to display product details to the user, and it needs to insert order details into the database when a user places an order. It makes sense to abstract the logic necessary to access data in a separate layer of data access logic components. Doing so centralizes data access functionality and makes it easier to configure and maintain.

Business entity components. Most applications require data to be passed between components. For example, in the retail application a list of products must be passed from the data access logic components to the user interface components so that the product list can be displayed to the users. The data is used to represent real-world business entities, such as products or orders. The business entities that are used internally in the application are usually data structures, such as DataSets, DataReaders, or Extensible Markup Language (XML) streams, but they can also be implemented using custom object-oriented classes that represent the real-world entities your application has to work with, such as a product or an order.

Components for security, operational management, and communication. Your application will probably also use components to perform exception management, to authorize users to perform certain tasks, and to communicate with other services and applications.

Some Software Development Cicle

2007-05-07T07:32:00.000-07:00

No Words!

S T R I D E - Threat Modeling

2007-02-22T13:08:00.000-08:00

Security Technology Is Only Part of the Solution

Implementing security is only part of the solution. Another important part is vigilance. Even if your system has many security safeguards, you need to watch it closely in these ways:

1. Monitor your system's event logs. Watch for repeated attempts to log into your system or for excessive requests being made against your Web server.
2. Continually keep your application server up to date with the latest security updates for Microsoft Windows and Internet Information Services (IIS), as well as any updates for Microsoft SQL Server or other data sources that your application might use.

Threat Modeling

An important part of developing a more secure application is to understand the threats to it. Microsoft has developed a way to categorize threats: Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege (STRIDE).

Spoofing

To spoof is to impersonate a user or process in an unauthorized way. At its simplest, spoofing can mean typing in a different user's credentials. A malicious uses might also change the contents of a cookie to pretend that he or she is a different user or that the cookie comes from a different server.
In general, you can help prevent spoofing by using stringent authentication. Any time someone requests access to non-public information, be sure they are who they say they are. You can also help defend against spoofing by keeping credential information safe. For example, do not keep a password or other sensitive information in a cookie, where a malicious user can easily find or modify it.

Tampering

Tampering means changing or deleting a resource without authorization. One example is defacing a Web page, where the malicious user gets into your site and changes files. An indirect way to tamper is by using a script exploit. A malicious user manages to get code (script) to execute by masking it as user input from a page or as a link.
A primary defense against tampering is to use Windows security to lock down files, directories, and other Windows resources. The application should also run with minimum privileges. You help guard against script exploits by not trusting any information that comes from a user or even from a database. Whenever you get information from an untrusted source, take steps to be sure it does not contain any executable code.

Repudiation

A repudiation threat involves carrying out a transaction in such a way that there is no proof after the fact of the principals involved in the transaction. In a Web application, this can mean impersonating an innocent user's credentials. You can help guard against repudiation by using stringent authentication. In addition, use the logging features of Windows to keep an audit trail of any activity on the server.

Information Disclosure

Information disclosure simply means stealing or revealing information that is supposed to be private. A typical example is stealing passwords, but information disclosure can involve access to any file or resource on the server.
The best defense against information disclosure is to have no information to disclose. For example, if you avoid storing passwords, malicious users cannot steal them. An alternative to storing passwords is to store only a hash of the password. When a user presents credentials, you can hash the user's password and compare only the hashes of the two. If you do store sensitive information, use Windows security to help secure it. As always, you should use authentication to help ensure that only authorized users can access restricted information. If you must expose sensitive information, it is recommended that you encrypt the information when stored and use Secure Sockets Layer (SSL) to encrypt the information when sent to and from the browser.

Denial of Service

A denial of service attack is to deliberately cause an application to be less available than it should be. A typical example is to overload a Web application so that it cannot serve ordinary users. Alternatively, malicious users might try to simply crash your server.
IIS enables you to throttle applications, which means that it limits the number of requests it will serve. You might be able to deny access to users or IP addresses known to be malicious. Keeping your applications online is a matter of running robust code. You should test your application thoroughly and respond appropriately to error conditions wherever possible.

Elevation of Privilege

An elevation of privilege attack is to use malicious means to get more permissions than normally assigned. For example, in a successful elevation-of-privilege attack, a malicious user manages to get administrative privileges to your Web server, giving himself or herself access to any data on the server as well as control over server capabilities.
To help protect against elevation of privilege, run the application in a least-privilege context if practical. For example, it is recommended that you do not run ASP.NET applications as the SYSTEM (administrative) user.

Basic MSF Models

2007-01-19T07:17:00.000-08:00

As part of the Process Model and Team Model from MSF.. I just want to have this info at hand because of its importance at the moment to start a project. In case of managers forget it.

A very short description of the Team Model Role's goals

More detailed

MS recommendation for combining roles. Like every step in the envisioning phase of the Process Model,when the complete application is being defined, this combination is so important but at the same time very sub estimated for organizations where there are not enough resources to assign to each role. Bad Bad!

Why .Net apps consume so much memory

2007-01-18T11:57:00.000-08:00

There are many posts out there where people ask why .Net apps consume so much memory…

I was researching a little and I found very interesting information that I'm going to comment here.

I, like every body else had a .Net 2.0 Windows application consuming a lot of memory. Initially I eliminated the possibility to minimize the application so it only could be hidden and visible again. When I saw the Task Manager (which now I know is not a good indicator or the real memory a .Net application is using) I was worry because of the high amount of memory being used. Researching I discover Windows allocates private memory (referred later as Private Bytes) and shared memory (private memory plus shared memory is referred later as Working Set) for one single application , and the shared memory can be released if the application doesn’t need it. Surprisingly when an Application is minimized Windows releases the application's shared memory making the value shown in the Task Manager very low. I tested it using some counters with the perform monitor. I added two counters for my application: Private Bytes and Working Set then Running and minimizing my App I got this output:

It shows how the Working Set drops dramatically, but Private Bytes stays flat. When I look the size of my app minimized in the Task Manager I saw it uses two or 3 MB of RAM. Wow!! Then I did the same test with Messenger and GoogleTalk and I got the same result. Windows frees memory when apps are minimized which is logic and great!

Something else I notice: When you don’t want to show your application minimized to users but still want Windows to release memory then the application’s window must be visible at the moment it is minimized for Windows to recognize the visible change.

e.g. If you hide the application and later minimized it by code like this

this.Hide();
this.WindowState = FormWindowState.Minimized;

Windows won’t recognize that it is minimized then keeping the complete memory allocated for the application (the mem value in the Task Manager does not change). The code should be like this for Windows to be aware that the application is not been used

this.WindowState = FormWindowState.Minimized;
this.Hide();

I’m going to copy here some interesting conclusion from Tim Anderson's page. (http://www.itwriting.com/dotnetmem.php)

1. Windows generally does a good job of memory management. High figures in Task Manager needn’t concern the user if the system is running well.

2. .NET applications really do have a high memory footprint relative to most native code applications (Java has the same problem).

3. Don’t use the mem usage column in Task Manager for diagnostics or profiling.

4. There isn't much developers can do about the memory footprint of the .NET runtime. However, there is a lot that developers can do to make applications that use memory efficiently and avoid leaks. This mostly involves looking at the .NET counters rather than the system counters. Use of a profiler is near-essential; I like the SciTech ( http://memprofiler.com).

Best Practices for SQL (Evolving entry)

2007-01-03T06:27:00.000-08:00

This is an incremental link. Those are links I wanted to put here to find quickly some best practices to design administer and maintain SQL databases.

Books online/ Sample Data bases. Always huge source of best advises.

SQL Best Practices
------------------------
http://www.microsoft.com/technet/prodtechnol/sql/bestpractice/default.mspx

Best Practice Analyzer tool
-------------------------------
http://www.microsoft.com/downloads/details.aspx?FamilyID=B352EB1F-D3CA-44EE-893E-9E07339C1F22&displaylang=en

Storage Top 10 Best Practices
------------------------------------
http://www.microsoft.com/technet/prodtechnol/sql/bestpractice/storage-top-10.mspx

Data Patterns (high level)
--------------------------------
http://msdn.microsoft.com/practices/compcat/default.aspx?pull=/library/en-us/dnpatterns/html/dp.asp

LAS VEGAS

2006-12-28T10:21:00.000-08:00

Just a break to celebrate (moreee) my 2months vacations in Las Vegas
I'm not going to write anything about it and I'm going to show you only 1 picture from 1500 I took because if you haven’t been there… You can get it!!

I already decided.. I'm going to live there!!

Working with PDFs

2006-12-28T09:55:00.000-08:00

Objective: I needed to use a PDF reader inside my windows application.

Requirement of my App:

1. Can't download the PDF files to the client computer
2. Can't use Acrobat reader or any other plug in/reader (named Helper Applications) that push the user to download it .So everything should be embedded in my app and the user need not to have any plug-in or browser pre-installed to see and print the PDF files.

Because the PDF file can not be downloaded to the user machine it is needed to navigate or to load the document into the reader giving to it an URL.

Alternatives:

1. Use the .Net WebBrowser control in my windows form and embed the reader or any PDF plug-in (not acrobat! it means I can not use the PDF Control that is include in VS when the acrobat reader is installed) into my Setup in order to install it unattended from the user. I never tried it!
2. Use a third party PDF browser-reader control (dll or ocx). I never found it!

3 Use a third party PDF reader control (dll or ocx) who is able to load PDF files from Memory Stream, URLs. I did it.

Solution:

I found a control “WPViewPDF” (an ocx) who is able to load a PDF from a stream and I implemented this method to get the stream from the URL:

--------------------------------------------------------------------------------
//Make a Request to the file and return it as Stream
WebRequest MyReq = WebRequest.Create(textBox1.Text);
WebResponse MyResp = MyReq.GetResponse();
Stream data = MyResp.GetResponseStream();

//Create the bytes array store the Stream
byte[] buff = new byte[MyResp.ContentLength];

//Read the Stream and Load the array
int len = 0;
int cnt;
do
{
cnt = data.Read(buff, len, buff.Length - len);
len += cnt;
} while (cnt > 0);
data.Close();
MyResp.Close();

//Recreate a Stream and pass it as a parameter
MemoryStream ms = new MemoryStream(buff);
pdfViewer1.LoadFromStream(ms);

Note:

Looking at this code I though What About if I want to save this info to a physical file?
I researched and I found this:

1. The easiest way to Download the file and save it to disk is using a WebClient

WebClient client = new WebClient();
client.DownloadFile(varURL, localFileName);

2. But If I already have a MemoryStream and want to save it to a file, this is the way to go:

using (FileStream stream = new FileStream("fileName", FileMode.Create))
using (BinaryWriter writer = new BinaryWriter(stream))
{writer.Write(ms.ToArray());}

I used it!

-------------------------------------------------------------------------------

Conclusion so far:

It works fine but the control does not render well the PDF file, so now I’m looking another control who can download a document from a stream.

Finally!!!!!!!! I found a control which satisfies the requirement my application has. It is an assembly very ease to use. A reader-printer not a generator (We use PDFLib to generate the PDF documents on linux also work for Windows). PDFReaderControls.NET from Tall Component (www.tallcomponents.com ) a company from Netherlands, the license price $2500. UUUh!!

I tried before those components:

PDF-tools: It is an ocx and gave me to much exceptions.
PDFXpress: They don’t have a release for .NET 2.0
WPViewPDF: Does not render some PDF correctly.
PDFNEtDemo: Does not load PDF from URLs

There is also some exceptions that happen when PDF is used with .Net and the PDF document has not been done following the rfc2616 specification (www.ietf.org/rfc/rfc2616.txt) and it is loaded from the WEB (via URI):

System.Net.WebException: The server committed a protocol violation. Section=ResponseStatusLine. A pain..!!

To help the community and avoid people from waste time reading and reading I’m going to give some links that show the story of this exception and the solutions.

Important to know:

Some .NET requirements for PDF documents (http://msdn2.microsoft.com/en-us/library/system.net.configuration.httpwebrequestelement.useunsafeheaderparsing(VS.80).aspx)

1. To help protect from "HTTP Response splitting" attacks, parsing is performed according to the document that is named Request for Comments (RFC) 2616. This means that all control characters are not permitted in names or in values. For example, the carriage return (CR) character and the linefeed (LF) character are not permitted. There are other characters that are not permitted in names. Additionally, every response header must have a colon.
2. Headers names should not have spaces in them.
3. If multiple status lines exist, all additional status lines are treated as malformed header name/value pairs.
4. The status line must have a status description, in addition to a status code.
5. Header names cannot have non-ASCII chars in them. This validation is performed whether this property is set to true or false.

Links to read about it:

http://blogs.msdn.com/mflasko/archive/2005/11/02/488370.aspx
http://support.microsoft.com/?kbid=888527
(search for "Undocumented bugs in the .NET Class Library (NCL)")
http://msdn2.microsoft.com/en-us/library/65ha8tzh.aspx
http://www.velocityreviews.com/forums/t302174-why-do-i-get-quotthe-server-committed-a-protocol-violationquot.html

Removing URL from the footer of a printed document

2006-11-20T07:06:00.000-08:00

It's kind of disappointed to know that There are some simple operations that still require the use of APIs and can't not be done entirely by using encapsulated .NET framework controls

Well so far I have encountered this:

To setup the header and footer when print a page (notice that I’m not talking about the header and footer of the webpage which can be solve using a PrintStyleSheet) I’m talking about the header and footer that appears in the Page Setup Dialog (you know the annoying URL)

I'm trying with the IE5. OCX control via interop that allows to pass a parameter for the header and footer of the pagesetup but I don’t want to go back using unmanage code.

Also I found this solution that require to change the keys entries in the registry. Of course it is necessary to have permission to write in the registry. The basic code is this and needs no explanation

--------------------------------------------------------------------------------------------
using Microsoft.Win32;

RegistryKey pageKey = Registry.CurrentUser.OpenSubKey("software\\microsoft\\internet explorer\\pagesetup", true);
string newFooter = "";
string newHeader = "";
object currentFooter = pageKey.GetValue("footer");
object currentHeader = pageKey.GetValue("header");
pageKey.SetValue("footerTemp", currentFooter );
pageKey.SetValue("headerTemp", currentHeader);
pageKey.SetValue("footer", newFooter);
pageKey.SetValue("header", newHeader);
pageKey.Close();

--------------------------------------------------------------------------------------------

Something to remember:

The header and footer entries in the registry maybe are not created yet in the user machine. Windows create those entries the first time the user accesses the PageSetup windows. So if you receive an exception maybe because the code is trying to read entries that are not created yet. You should check first.

It was useful for me at the time I had a WebBrowser2.0 control running inside a windows form (VS2005 )so I could access the registry from my windows application. I have not use this code from a WebPage which require more code and some JavaScript to manipulate the registry but in this link is a sample showing it.

http://www.codeproject.com/useritems/Removing_url_in_print.asp?df=100&forumid=346298&select=1766196&msg=1766196

Test it!! and let me know.

Microsoft and Novell Announce Broad Collaboration on Windows and Linux Interoperability and Support

2006-11-19T17:28:00.000-08:00

Hey.. That is money and more money for these companies. Windows and Linux control the computing world and each year companies require specialized people like us who are on the edge of technology. Shouldn’t we (Microsoft and Linux specialist --by the way we are like 5Millions in the entire world) be earning more money each year. Our brains are going to the same rhythm of this huge amount of information... Come on.

REDMOND, Wash., and WALTHAM, Mass. — Nov. 2, 2006 — Microsoft Corp. and Novell Inc. today announced a set of broad business and technical collaboration agreements to build, market and support a series of new solutions to make Novell and Microsoft® products work better together. The two companies also announced an agreement to provide each other’s customers with patent coverage for their respective products. These agreements will be in place until at least 2012. Under this new model, customers will realize unprecedented choice and flexibility through improved interoperability and manageability between Windows® and Linux.
“They said it couldn’t be done. This is a new model and a true evolution of our relationship that we think customers will immediately find compelling because it delivers practical value by bringing two of their most important platform investments closer together,” said Steve Ballmer, CEO of Microsoft. “We’re excited to work with Novell, whose strengths include its heritage as a mixed-source company. Resolving our patent issues enables a combined focus on virtualization and Web services management to create new opportunities for our companies and our customers.”
On-Demand Webcast
You can view an on-demand Webcast of the News Conference with Microsoft CEO Steve Ballmer and Ron Hovsepian, president and CEO of Novell, held Nov. 2.
View the Webcast (53 min. 34 sec.)
Under the agreement, Novell is establishing clear leadership among Linux platform and open source software providers on interoperability for mixed-source environments. As a result, Microsoft will officially recommend SUSE Linux Enterprise for customers who want Windows and Linux solutions. Additionally, Microsoft will distribute coupons for SUSE Linux Enterprise Server maintenance and support, so that customers can benefit from the use of an interoperable version of Linux with patent coverage as well as the collaborative work between the two companies.

Usign ORM

2006-11-19T08:04:00.000-08:00

I use the software they mention here and It help me a lot!!

I copied this article from this link: Frans Bouma's blog

Solving the Data Access problem: to O/R map or not To O/R map

On the http://www.asp.net/forums (the architecture section), a person asked in the 'Your favorite O/R mapper' thread, why someone would use a 3rd party component for data-access and why would that be an O/R mapper and if so, which one?

Q: why would I go out and buy a 3rd party component / library?

A: With every task you have to perform during a software development project, you have to make a calculation: if I perform this task myself, how much time will that take, and given my hourly fee, how much money is involved in it, minus the knowledge I gain from doing it myself and the insight it gives me. The number resulting from that calculation is compared to what a 3rd party component costs + how much time it will take to get used to the 3rd party component + the time to figuring out which component is good + some risk calculation (because a 3rd party component can turn out to be a bad choice after all after a month or so). This sounds awkward, but it's common sense. It's not always more efficient to go out and buy a component to do things for you, like it's not always more efficient to do things yourself. However without making a simple calculation, it's hard to tell in which situation you're in. Software projects are hard to manage, and without tight cost control, or better: cost insight, it's hard to make a project be run efficient and profitable. So even if it's tempting to go out and buy a component or use an open source component, is it really more efficient to do so? Often it is, don't get me wrong on that, but don't forget the costs of using a 3rd party component, especially when it's a freebee without any documentation and just a raw example program without a lot of comments.

Q: why should I implement an O/R Mapper in my projects?

A: O/R mapping is in theory very simple: you have a table field and you have an entity field and you define a connection between them and use that connection in your logic to provide functionality like load a class' data, save it, etc. etc. However using solely the terms 'O/R mapping' and 'O/R mapper' is only making things more complicated. The problem description is:
"I have to make a connection between my business logic and my persistent storage, how do I do that?".
The answer: "use an O/R mapper" is not helpful, as it would require knowledge about what an O/R mapper is. If you don't know what it is, how can you judge if an O/R mapper is helpful and if that answer holds some truth? You can't. The right answer is a question: "how do I see my data?". It's the cornerstone of the answer leading to the solution of the dreaded Data-Access problem. There are a couple of different views on 'data' which result in different ways of how the DataAccess problem is solved. You have: 1) table approach 2) entity (Chen/Yourdon) approach 3) domain model (Fowler/Evans) approach(these are the top 3. There are others, most of them fall in either of these 3 categories though). 1) and 2) look the same, but aren't. Let's discuss these 3 views more in detail.1) Table approachThe table approach is the plain 'I use tables and query them' approach. No theory used, just a set of tables, not based on any abstract model, they're created right there in DDL. The developer uses tables and is expecting to work with tables in memory as well, so a plain dataset/datatable approach with stored procedures or VS.NET-generated SQL statements is an appealing approach. Typically, the developers using this approach use terms like 'rows' and 'customer record'. It might sound odd, but this is a very widely used approach on .NET. The reasons for that are that Microsoft preaches it through VS.NET designers and -examples and because in the pre-.NET period, ADO with recordset objects was the way to go. 2) Entity (Chen / Yourdon) approachThe entity approach is different. The relational model is build with an abstract model and is based on theory. This means people speak of entities (or if you want to go really deep into theory, relation) and attributes. An approach with solely DataTables / DataSets is often not appealing, as the relational model speaks of Customer Entity and not about Customer record. Developers using this approach want to use these type of elements also in their code. As they use a relational model as their base of their thinking, the entities by definition don't contain behavior/rules or just low level behavior/rules, like the checkconstraints/unique constraints and other constraints defined like 'shippingdate >=orderdate' or 'id >=0'. Also important is the way the developers want to utilize the relational model. They understand that the data in the database is just data, and an entity is just a relation based on attributes, which can be constructed dynamically as well, with a select statement. This is important for lists of combined attributes from different entities and reporting functionality. The entity approach uses a combination of O/R mapping for the entity data and generic data functionality like Datasets / DataTables for the dynamic data retrieval requests. The entity approach is also widely used, you see it more in the larger applications as these applications often require a system architect and data analyst. It's proven technology which exists since the late '70-ies of the past century. 3) Domain model (Fowler / Evans) approachThe Domain model is an approach which is the most used approach for solving the Data Access problem in the Java world, but interesting enough rather rare in the microsoft world. This is not that surprising, as in the Microsoft world it was simply unknown: Microsoft never talked about it, the techniques mostly used by the tools used by developers didn't support it very well, so running into it was not that common, only perhaps when you talked about Data Access with Java developers for example. Another reason it is not that widely used, is that it requires an OO approach which wasn't often possible with COM objects and/or VB5/6. The domain model focusses on domains, like the Customer domainor the Order domain. It starts with classes, like a Customer class, which contains the data for a customer but also all behavior for the customer, so all business rules for the customer are stored there. (This is somewhat simplistically said, there are a couple of variants of course, but for the sake of the argument, let's keep it with this description). Through inheritance you can create a compact model of classes and store the behavior you have to define in the class it belongs in, using polymorphism to override/modify behavior through the hierarchy. The classes / class hierarchy is then stored in a persistent storage, typically a database. This is a fundamental difference with 2) : with the Domain model, the relational model follows classes, classes don't follow the relational model. Typically, behavior in 2) (and also 1)) are stored in functionality objects like CustomerManager, which embeds the customer functionality, and which is applied to behaviorless entity objects. In 3) you have the behavior in the class, no manager classes. 3) requires an O/R mapper to work with the data in the persistent storage or better: the O/R mapper is required to (re-)instantiate entity objects from their persistent state in the persistent storage. Because the system focus on data is through objects, working with data like in 2) and 1) is not available, it's working with objects. What's the best approach?Hard to say. 25 years of 2) in millions of software systems around the world can't be wrong, however millions of software systems in Java using approach 3) can't be wrong either. I think it largely depends on what you think is more logical, how you want to work with data. I'm in camp 2), and our product LLBLGen Pro is a tool which tries to help with 2) by offering both O/R mapping and flexible relational model data access power. It's therefore not a pure O/R mapper as it doesn't fit that much in 3), it offers more functionality, to help with 2) than with 3). Also Paul Wilsons WilsonORMapper is more of a category 2) than category 3) application. More pure O/R mappers, like EntityBroker, DataObjects.NET, NHibernate and others focus on 3) (most of the time). Don't think lightly about this, the differences are fundamental and will influence how your system structure is designed for a great deal. So it's important to pick the approach which fits your way of thinking. To test how you think about data, ask yourself: "A customer gets the Gold status when the customer has bought at least 25,000$ worth of goods in one month. Where is that logic placed? in which class/classes?". Inside the Customer object, reading inside the customer object order data to test the rule? Or in a CustomerManager which executes rules and consumes customer and order objects? Also don't let your decision be influenced by "but this example proves x is better than y!": at the end of the day, data is data and not information. Information is data placed into context, and it requires interpretation to give it any value/meaning. How you do that is not important, as long as you meet requirements as: maintainability, scalability and efficiency in development, deployment and perhaps (but not necessarily) performance. So if your way of writing software is clearly in the Fowler/Evans camp, 3), don't use datasets, don't use a Data Access solution targeting 2) because it will be a struggle: the way of thinking doesn't fit the tool used: you want to drive in a nail with a screwdriver, you should either switch the nail with a screw or use a hammer instead of a screwdriver. So if you're in camp 3), use a pure O/R mapper, it will fit like a glove. If your way of thinking is clearly in the 2) camp, using a pure O/R mapper can give you headaches when you want to write a lot of reports, you want to use a lot of lists combined from attributes of multiple entities, you need functionality which allows you to perform scalar queries, and an approach which allows you to think from the relational model, so an application which has an approach tailored on starting with the relational model.