Infosys Microsoft Alliance and Solutions blog

« April 2007 | Main | June 2007 »

May 31, 2007

Microsoft Surface

Imagine you are in a restaurant where you can browse the menu, order and split your bill using your fingertips literally! Microsoft has made this a reality by bringing computing to your table, with a revolutionary techology called Microsoft Surface.

Microsoft Surface is a computer in form of a table which uses a 30 inch tabletop as it's screen. It allows several users to interact with it using touch and hand gestures. There is no need for keyboard or a mouse.

Here are few scenarios where this technology can be used:

  • Place a cell phone on a tabletop. It shows the features of the cell phone,pricing and different plans the provider is offering. Now you can customize the service plan offerings by dragging and dropping icons.
  • Diners split a tab by dragging meal icons to their credit cards.
  • Place a card on the table and it pulls all the digital photos from a server, which you can arrange across the table.
  • Gaming, Music playlist browsing, painting and virtual concierge etc.

Microsoft may eventually change shape of surface computer depending on where it is used . Who knows you may someday have one of these gizmos hanging on your refrigerator!

Check out this cool technology here

Microsoft Surface: Behind the Scenes

May 30, 2007

Hello World!

A warm welcome to Infosys blogs on Microsoft technologies.

I am Sriram Balaji, a Senior Technical Specialist working at Microsoft Technology Center at Infosys. I have been in the IT industry for around 9 years now. I have worked on VB, ASP, ASP.NET 1.x/2.0, .NET Framework 1.x/2.0, SQL Server. My current areas of focus are Software Factories, software frameworks and .NET 3.0.

Do watch  out this space for reviews about upcoming MS products and do feel free to share your views on upcoming technologies from MS.

May 28, 2007

MSMQ - Receiving messages from remote private queues

Sometime back I had blogged about how to send messages to remote private queues. There were a few queries on how to read from remote queue as well.

To me it should have worked by using the MessageQueue.Receive API instead of .Send. I decided to give this a try anyway and it indeed is as trivial as that. However a few things to take care while trying to get this working.

1. Check the documentation to see where all the API works. The API may have limitations in working in workgroup mode if you are not using the direct format name syntax.

2. The other very important aspect is setting the formatter prior to receiving the message. You need to set this appropriately to binary or XML and specific type to ensure successful read.

To show a complete example, find below code that posts to the remote queue (transactional as well as non-transactional) and also reads from them. To keep things simple, I have used a simple string message here. However you can definitely use more complex types and custom types for sending and receiving (as long as they match both ways).

        private void btnPostToQueue_Click(object sender, EventArgs e)

        {

            //post to regular non-transactional remote queue using OS name

            MessageQueue rmQ = new MessageQueue("FormatName:Direct=OS:punhjw30076\\private$\\remote");

            rmQ.Send("sent to regular queue - Atul");

 

            //post to  transactional remote queue using IP address

            MessageQueue rmTxnQ = new MessageQueue("FormatName:Direct=TCP:100.100.100.12\\private$\\remoteTxn");

            rmTxnQ.Send("sent to transacted queue - Atul", MessageQueueTransactionType.Single);

        }

 

        private void btnGetFromQueue_Click(object sender, EventArgs e)

        {

            //retrieve from regular non-transactional remote queue using OS name

            MessageQueue rmQ = new MessageQueue("FormatName:Direct=OS:punhjw30076\\private$\\remote");

            rmQ.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) });

            System.Messaging.Message msg = rmQ.Receive();

            MessageBox.Show(msg.Body.ToString());

 

            //retrieve from transactional remote queue using IP address

            MessageQueue rmTxnQ = new MessageQueue("FormatName:Direct=TCP:100.100.100.12\\private$\\remoteTxn");

            rmTxnQ.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) });

            System.Messaging.Message msgTxn = rmTxnQ.Receive(MessageQueueTransactionType.Single);

            MessageBox.Show(msgTxn.Body.ToString());

        }

Hope this helps !

May 25, 2007

Software Factory: Domain-Specific Modeling

Have you noticed that dirty stare your developer gives you, when you walk up to him with a change in requirement? Let’s see – there needs to be an impact analysis, change of design, change of code, more dirty stares, updating dependencies, regression tests, more change of code, more dirty stares. And then there is another change in requirement. You figure.

Fast changing businesses are often categorized by fuzzy or frequently changing requirements. In such times which are increasingly becoming the new orders of the present day, changing requirements result in seriously impacting the IT systems. Lack of time, investment, human resources and intense pressure from competition makes it an enormous task to keep software development constantly streamlined vis-à-vis their change in requirements.

A single change in requirement could actually mean revisiting the design and the code of the software being developed, rewriting your test cases, and regression testing the dependent components. And this in turn impacts the go-live deadlines, eventually affecting the business, the time to market, and finally your bottom line, and you get another dirty stare – this time from your CEO.

The need of the day is to provide a way for the businesses to define the context and model the business processes and their dependent activities, which can directly feed into the core technical design and code. This way the ever-widening gap between proper understanding of requirements and converting them into technological outputs is minimized to a great extent. In case of fuzzy or fast changing requirements, the business user would be able to re-model his business activities to reflect the change in business and the natural mechanism would automatically update the relevant design artifacts and code, thereby optimizing time, as well as validating the system for regressive impacts.

Domain-Specific Modeling (DSM) is what we are driving it. The days of dead diagrams drawn using a modeling tool, which – at its best – can generate some dumb classes without any context of what business it is into, is fast giving way to creating intelligent models which can understand and act according to its business. DSM is a way of creating your own vocabulary specific to your business domain and technology, which can be used by the business user to define his requirements and lay down his expectations from the upcoming software system. And then use a combination of various mechanisms built around DSM concepts to design, generate code and test scripts based on the models.

DSM is the soul of Software Factories, and what makes it the call of the future is the neat way it deals with the following two types of systems.

1. High Complexity Systems
2. High Evolvement Systems

In the next post, I’ll discuss the role of DSM in developing and maintaining High Complexity Systems.

May 18, 2007

Software Factory: Towards the Holy Grail of Software Development

Remember the days when you used to punch some quirky looking characters on a flickering green screen they used to call a "computer"? I guess most of us were not even born then.

Today with the luxury of High Level Languages (Man! When was the last time we spoke about "high level language"?) and sophisticated IDE with stuff like intellisense, software development has reached a new peak altogether. And so has the complexity of software systems.

The business, from the days of the green screen, has grown manifold to what it is today, and it's changing faster than ever. Software development methodologies have been trying to keep pace with the changing businesses finding new ways of addressing complexities and dynamism. Despite all the tools, complexities have been on the rise and the line connecting business and technology has continues to be elusive.

Increasing sophistication has only taken us so far, while a host of other issues from developer productivity to receptiveness to changes, faster production, adoption of standards, creating more predictable and sustainable systems have been a huge onus on the technology communities. One way the developers have tried to counter this is by creating reusable artifacts, frameworks and components. But for a swifter, cost-effective business, technology keeps changing so fast, that the reusable components itself may have to be revisited and updated every few months and hence increasing the overall development, maintenance and support cost of these components.

Today, we are at the forefront of another evolution. High Level languages with their english-like syntax will soon give way to business flow diagrams which would have the ability to emit and manage code all by themselves. Much like the assembly lines in the manufacturing industry where a base product line is created, and modified to come up with different variants, the current phase of the evolution is based on identifying software product lines and coming up with variants to suit specific businesses. This is broadly called Software Factories.

I’ll be writing more on the views, theories and practices of this next big thing in software evolution in the coming days.

May 14, 2007

WindowsClient.net

New Winforms and Windows Presentation Foundation (WPF) community site - http://windowsclient.net/Default.aspx. Lot of material to help developers... do check out the video section for a good collection of video tutorials