We had some solid requirements and prototyping on some new features. I had demonstrated one of the prototypes integrated to the product which essentially play back the images aligned to the ECG cycle acquired from the cardiac patient. The feature helps the sonographer to export the data as AVI. I simply tested the feature and quickly setup the demo as we’ve already crossed the deadline. Things were working just fine. This I had already seen in the prototype earlier. Fine. I demonstrated the feature successfully and was happy about it. I requested him to to try the new feature to get more feedback from him. He happily took over the system.

He simply registered a patient, then acquired the images along with ECG. He went on reviewing the acquired images, then he exported the cycles as AVI to the patient. He quit the application and opened the patient browser if appears under the current patient. Yea it’s there. I dint feel anything bad when he registered one more patient and start the application again. (Application won’t quit, it will be residing in memory always. They simply hide the window and release the resources and keeps on waiting for commands from parent application). He did the very same procedure again. It was working I was happy again. The progress bar has been displayed again and finished the export. Then he took the patient browser once more. Surprisingly the data wasn’t there under the current patient.

As I knew the code base well, I figured out within seconds what made it to disappear the data. I told him “I’m sorry, the new patient event not handled well. The code isn’t resetting/replacing the patient ID with new one. I can fix this. It’s just one line modification” and I was about to go back to my desk to modify the source.

He stopped me and smiled and explained, “Sarath-san, are you realizing that this is a serious security issue?” I could not fully understand what he really meant with security issue.

I did not reply. He continued “For programmers, it’s a one line code modification which takes to fix this issue. But think from a customer perspective. If you went a hospital with some small chest pain and the next patient is coming with some serious cardiac problem and what if his data being exported to your ID, then the doctor gives you the wrong treatment?”

The example was perfect. I could not think of a major heart surgery because of a system/sonographer’s mistake. That was kind of eye opener. Even after all these years I still remember the story.

Most of the time, programmers are either instructed to do some part of the code without having understanding of the impact. To make and maintain better software, it is also important to understand what is the big picture. What is the real impact. Always remember the issues being found during the development time is easy to fix, once it’s delivered to the customer site, the cost will be N times more, depends on the number of customers we’ve and the cost of deploying the patches. It starts from requirement capturing to implementation. It’s responsibility of the person who captures the requirements to test/inform the major uses cases, aspect and impact of the features. On the other hand, when we’re implementing something, it’s solely our responsibility to properly understand the requirement, big picture of this requirements and the impact area. It’s equally important to do regression testing to make sure that the existing functionalities aren’t broken.

When less competent people leads these activity there’s a high chance to have the information in pockets and do not explain the requirements properly to make sure that they’ve better control over the project (trust me, there are people). But that is actually making the product and themselves worse. Also it’s developers responsibility to bug the people enough to get maximum information and clarify the requirements.

We can do the hand written loop to remove the elements from the container. For e.g. if you want to remove an element vector you can do something as below. (note erasing element from a C++ container within a standard for or while loop with simple iterator++ will end up undefined result)

vector::iterator it = vec.begin();
while(it != vec.end())
     if( *it == 5 )
         it = vec.erase(it); // Remove and take the return of the erase function to safely reassign
     else
         ++it;

The above code is simple as it appears, it simply iterate through the elements and find if a match there for the value then remove it from the container. And it takes back the value returned form erase where it returns the iterator of the next element. If no more elements, it will vector::end

Now, the containers will have different implementations for the same function. A map::erase return void. So it’s difficult to give a single and easy strategy for each type of containers.

remove is a handy function defined in algorthm It’s easy to get confused to know what it does and distinguish between erase. remove remove (move) the elements from the given range. Mostly push it towards the end of the container. The function returns an iterator to the location where the moved elements located within the container. It essentially won’t remove the elements as such from the container. Here is the sample demo of using remove

// remove algorithm example
#include 
using namespace std;

int main ()
{
  int data[] = {10,20,30,30,20,10,10,20};      // 10 20 30 30 20 10 10 20

  // bounds of range:
  int* pbegin = data;                          // ^
  int* pend = data+sizeof(data)/sizeof(int);   // ^                       ^

  pend = remove (pbegin, pend, 20); // 10 30 30 10 10 ?  ?  ?
                                    // ^              ^

  return 0;
}

Now this handy function has an alternative version to give a comparator function which can accept the object of the type specified for the container. Inside the function, you can make decision to remove or not by specifying in the return value. In simple words, rather giving a comparison hard coded value, we’ll give a function to make decision for us. See the documentation and example here.

Erase-Remove tequenique is accomplished in following ways.
1. Move the elements to be removed to the end with the help of remove function
2. Take the return of remove and pass to the erase function as beginning and containers::end as end.
3. Finally the contianer will contains the elements which are not satisfying the comparator function/value.

#include  // the general-purpose vector container
#include  // remove and remove_if

bool is_odd(int i) { // unary predicate returning true if and only if the argument is odd
  return i % 2;
}
bool is_even(int i) { // unary predicate returning true if and only if the argument is even
  return !is_odd(i);
}

int main() {
  using namespace std;
  int elements[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  // create a vector that holds the numbers from 0-9.
  vector v(elements, elements + 10); 

  // use the erase-remove idiom to remove all elements with the value 5
  v.erase(remove(v.begin(), v.end(), 5), v.end()); 

  // use the erase-remove idiom to remove all odd numbers
  v.erase( remove_if(v.begin(), v.end(), is_odd), v.end() );

  // use the erase-remove idiom to remove all even numbers
  v.erase( remove_if(v.begin(), v.end(), is_even), v.end() );
}

Reference:
Erase-remove idiom

I find this is promising. Especially, with Visual Studio 2010, we’ve found completely revamped architecture for extending Visual Studio. On the other hand, Whole Tomato is a company, which had shown what customers really wanted out of Visual Studio. Their Visual Assist X plugin is an excellent piece of art. There are other famous guys who sells similar softwares like DevExpress. But I personally prefer VA, because it’s light weight and not leaving much confusions with cluttered interfaces like others.

Visual Studio Power Tools is another awesome free option to improve your productivity. But I believe Microsoft can do well with their IDEs. Ever since Visual Studio 2003, we’ve not gained anything better out of Microsoft IDEs. Almost 8 years, though Microsoft has introduced a bunch of technologies and language improvements especially for C#, the IDE remains a substandard for the world’s biggest developer community.

Visual Studio 2011 is a positive improvement where the art of search with regular expression integrated well with to find information quickly.

Read the full scoop here in Soma’s blog

But WinDBG and .NET call stacks aren’t in a good sync. We will have to load SOS.dll or SOSEX.dll to get better help with debugging.

You can use !EEStack of SOS.dll to display call stack of all threads.


.load C:\Windows\Microsoft.NET\Framework\v2.0.50727\SOS.dll
!EEStack


•Fixing a bug early avoids wasted time debugging strange crashes or reliability issues later on.
•Fixing a bug early avoids resetting/repeating testing after a bug is fixed late in the development cycle.
•Fixing a bug early avoids the complexities associated with fixing it if it is exposed after the application ships.

The Security Science team with the Microsoft Security Engineering Centre (MSEC) worked closely with the Visual Studio Code Analysis team to ensure that the Visual Studio Developer Preview includes as many of the SDL mandatory C/C++ Code Analysis warnings as possible. These are the security-related warnings that Microsoft considers critical to fix for internal C/C++ software development.

This feature is included in Visual Studio 2011 Express as well.

read more

One of the most significant innovations we have brought to Visual Studio 11 is a series of tools for assisting you in developing Direct3D games. We made a quick video of some of these features on Channel9 (link). In this post, I will walk through our debugging & diagnostics support for D3D.

The new Graphics Debugger in Visual Studio is a debugging and analysis tool that captures detailed information from a Direct3D application as it executes. You can use it to:

• Capture rendered frames for later inspection and analysis.
• View DirectX events and their effects on the application.
• View 3D meshes before and after vertex shader transformations.
• Discover which DirectX events contribute to the color of a specific pixel.
• Jump directly to the location in source code for a particular DirectX call

• Find the program from the start menu
• Simply press Ctrl+Shift+Enter

Detailed

I was fed up on right-clicking programs and choose “Run As Administrator” to run in the elevated mode. I can simply set the properties of any programs in Vista/Windows 7 to always run as administrator. Or simply you can turn of UAC, in the worst case I can turn of few services to make explorer to run as administrator always.

But rather I prefer to use

• Find the program from the start menu
• Simply press Ctrl+Shift+Enter

using System.Security.Principal;
public bool IsAdmin()
{
    try
    {
        WindowsIdentity user = WindowsIdentity.GetCurrent();
        WindowsPrincipal principal = new WindowsPrincipal(user);
        return principal.IsInRole(WindowsBuiltInRole.Administrator);
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
        return false;
    }
}

[For the easiness of expressing, I prefer C# over C++.]

class FileSystem
{
    public static FileSystem getInstance()
    {
        if( instace == null )
            instace = new FileSystem();
        return instace;
    }
    private static FileSystem instace;
}

The above is a simple singleton class. But when the the instance is being accessed from multiple thread, we will have to employ some synchronization mechanisms to avoid the issues.

class FileSystem
    {
        public static FileSystem getInstance()
        {
            lock (lockObj)
            {
                if( instace == null )
                {
                    instace = new FileSystem();
                }
                return instace;
            }
        }

        private FileSystem()
        {
        }
        private static FileSystem instace;
        private static object lockObj = new object();
    }

Yes we’ve synchronized it better. Now what’s the issue, the instance creation is synchronized but this is a single time activity. i.e the instance is created only once by either of the threads. During the life time of the program, the lock which is employed is not really necessary. Each time a thread call FileSystem.getInstance(); it enters the costly lock(lockObj); statement rather than returning the already allocated object.

How to sort this issue? Double null checking is a famous technique to avoid the overheads caused by the locks for already allocated instance objects.

See a sample implementation

namespace DoubleNullCheck
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                Thread t = new Thread(Program.doWork);
                t.Start();
            }

            Thread.Sleep(2000);
            bStop = true;
            Thread.Sleep(1000);
            Console.WriteLine("Exiting...");
        }

        static void doWork()
        {
            while (!Program.bStop)
            {
                FileSystem fs = FileSystem.getInstance();
            }
        }
        public static volatile bool bStop = false;
    }

    // Singleton class
    class FileSystem
    {
        // getInstance with double null check
        public static FileSystem getInstance()
        {
            if( instace == null )
            {
                Console.WriteLine("1 depth null check" + Thread.CurrentThread.ManagedThreadId);
                lock (lockObj)
                {
                    Console.WriteLine("entered lock" + Thread.CurrentThread.ManagedThreadId);
                    if (instace == null)
                    {
                        Console.WriteLine("2 - Newing the object" + Thread.CurrentThread.ManagedThreadId);
                        instace = new FileSystem();
                    }
                    else
                        Console.WriteLine("2 - Ohh thread is already allocated" + Thread.CurrentThread.ManagedThreadId);
                }
            }
            return instace;
        }

        private FileSystem()
        {
        }
        private static FileSystem instace;
        private static object lockObj = new object();
    }
}

What happens here?

Thread 1 calls the getInstance() method and determines that instance is null at //1st null check
Thread 1 enters the if block, but is preempted by thread 2
Thread 2 calls the getInstance() method and determines that instance is null at //1st null check
Thread 2 enters the if block and creates a new Singleton object
Thread 2 returns the Singleton object reference
Thread 2 is preempted by thread 1.
Thread 1 continue it's execution and realize that, the object is alrady created (at 2nd null check) and returns
The subsequent calls to getInstance from any threads simply returns the instance after null check

Thus we can improve the overhead of unnecessary lock checking!

In my best understanding, the smart-screen filter is integrated with Windows Defender which is the built-in system-wide security service for Windows 8. No other settings are available in the Developer preview to control the settings for the same.