These two books (The Geometry of ) and ‘Asimov on Physics’, helped shed light on the issue.

The first conjecture – Light is like sound – the constancy of its speed is due to the ‘medium’ a.k.a – The Ether Theory

Consider sound waves. When you fire a gun, the wave travels through the air at a certain speed. This speed is independent of what the gun is doing – if the gun were moving straight ahead – the sound wave would still travel at the same speed. This is because the wave is dependent on a medium –  and the medium is what limits its speed.

Now – people already knew that the speed of light was a constant – and it did not depend on whether a flashlight was moving or not . So – based on the reasoning above, it seemed logical to assume that it was similar to a sound wave – that light too, required a medium. This was a logical assumption. The only problem was that the speed was so high that the medium would need to be very dense. At the same time, the medium could not interact with any matter (since light traveled without any problem through space devoid of matter). How do you construct a super-dense medium that does not interact with matter?

Michelson and Morley decided to put the existence of such a ‘medium’ to the test. The ether was assumed to be a completely stationary, non-moving object.

If the earth is moving through this stationary ether, then the earth should experience an ether ‘wind’ – the same way that a man sitting atop a train experiences a moving wind. If we now shine a flashlight in the direction of earth’s motion (against the wind), that light should take longer to reach its destination. Remember – it is the ETHER that is assumed to be ‘carrying’ the light wave. That is why – going against the ether should take longer. Similarly, going in the same direction should take less time. To paraphrase a quote in this detailed article:

The whole point of bringing in the aether was to give a picture for light resembling the one we understand for sound, compressional waves in a medium.

They devised an experiment measuring the time it took light to go ‘against’ the ether wind – and then ‘with’ the ether wind. They found that there was no difference in the times. This meant that there was no ‘ether wind’. So – light was NOT like sound – it’s constancy of speed did not have to do with any medium.

The Second Theory – Light  is like bullets – it’s speed should add/subtract from the source (the emitter theory)

Even though it was understood in Einstein’s day that the speed of light DID NOT in fact, add or subtract from the speed of the source, this could not be measured accurately in the days when Michelson Morley did their experiment. Recently, however, light emitted from moving pions (moving close to the speed of light) was measured  – and found to always move at the speed ‘c’. Thus, the moving source had no effect on the speed of light.

The actual experiment

This post discusses the experiment with great clarity. The analogy of the two swimmers in a moving river helps understand the experiment better. Two swimmers decide to have a race. A river is flowing at a speed of 3 m/s. Both swimmers swim at the same speed – 5 m/s. Swimmer A will try and swim directly across the river – and come back to the same point (he will obviously have to aim at a higher point on the opposite bank to be able to return to his original starting point). Swimmer B – will simply swim upstream (along the same bank that they both start at) – and then downstream to return to the starting point.

Who finishes first?

Note: They both swim the same distance (the width of the river is 50 m – swimmer A obviously swims 100 m, swimmer B will swim upstream 50 m and back again to complete his 100m).

Swimmer A’s effective speed will be 4 m/s (sqrt of 5 squared – 3 squared). So – A completes 100 m in 25 minutes. B covers the first 50 m (upstream) at a speed of 2 m/s (5 –3) = 25 minutes. He covers the second 50  m (downstream) at a speed of 8  m/s – in 50/8 = 5.2 minutes. Overall, A finishes in 25 minutes, B in 30.2 minutes. A wins.

Similarly, if two beams of light were to ‘race’ – one going diagonally across the ether (river) – and the other upstream and back, the one going across should return first. This would prove that there is such a thing as an ‘ether’ that carries the light wave.

It turns out no matter how precisely this experiment is carried out, both the light beams return at the same time. This proves that the river is not flowing (there is no ether).

Summary

It was thought that light was like sound. This led to the construction of an ether. The ether was experimentally proved to be fiction. It was also thought that light should behave like bullets from a moving gun – it’s speed should depend on the motion of the source. This was also disproved. So – light doesn’t behave like ordinary matter (bullets), it doesn’t behave like well-known waves (sound). Yet – it’s speed was always a constant  – regardless of the motion of the source. How was this possible?

Einstein postulated that light did not just travel in space – it traveled in something called space time. If you think of spacetime as your ‘ether’, you may be closer to the original conception of the ether. 

You have just started working on an existing codebase – an n-Tier project – and noticed that the Exception Handling framework wasn’t as well defined as you would expect. Some specific things that bother you include:

1. Lack of a Custom Exception Class
2. No clearly defined single layer (of the n-Tiers) which was designated to handle all exceptions. All the tiers seemed to be handling one or more exceptions.
3. Anytime an exception needed to be re-thrown (e.g. SqlExceptions and SOAPExceptions), it was through ‘throw ex’ – instead of just throw.

The Solution

Each of the  issues listed above are discussed in this post. A sample solution that defines a custom exception class – along with a simple client showing its usage – is included. This can be used as a starting point for any Custom Exception handling module inside a .NET project.

Custom Exception Class

n-Tier app – Exception handling

Q) Which tier (layer) should you catch the exception in?

A) Always the business tier. Let the Data Access Layer and any other layers (e.g. the persistence/entity layer) rethrow the exception upwards. Then – in the business layer, wrap the caught exception in your custom exception (e.g. MyAppException) using the method shown above  (which appends all the inner exceptions to the  MyAppException).

Q) How and where should one display the exception message?

A) Certain exceptions have no business being displayed to the end user. Simply log these in an exception log – and do not rethrow these exceptions. However, a good set of exceptions do need to be displayed to the end user. The exception that we previously caught in our business layer – simply needs to be rethrown with a user-friendly message. This is then is caught in the presentation layer (webforms or winforms) – and the friendly exception message is displayed.

Throw versus ThrowEx

Most exception handling code that you see will look the code below:

With the code above (throw ex), the stack trace is truncated – and only offers information starting from the method that failed. The origin of the exception will always appear to be in application code. However, as we all know, this isn’t always true. Exceptions can originate in various external systems – and eventually get thrown as CLR exceptions. Some common examples include

1. SqlException – exceptions generated at the Database driver/Data Access Layer .
2. SoapException – exceptions generated outside of the process boundary altogether – and passed into the CLR as a general SOAP exception

So – what is the solution?

The solution is to use throw instead of throw ex. Throw retains the entire stack trace.

On catching exceptions in database code (inside a database stored procedure)

If you have part of your business logic in a stored procedure (there are good reasons why this provides the best data access layer performance), then chances are your stored procedure is doing its own exception handling. It may be throwing and catching its own database layer exceptions. This is a terrible idea – considering the number of possible different exceptions that can occur in a database. Everything from integrity constraints being violated to incorrect SQL syntaxes to what not. To even attempt to identify the root cause of such errors without the database specific debug information – is nightmarish. I was part of a project where developers routinely went through this nightmarish exercise.

The exercise is meaningless since it is trivial to simply rethrow the stored proc exception to the database driver (and hence up to the data access layer). This provides meaningful information to a developer who needs to identify the source of the error. This changes the entire troubleshooting sequence from a ‘trial and error’ investigation – to a ‘simply look at the detailed exception – e.g. integrity constraint violated’.

Once I made these changes to all the stored procedures (simply re-threw all exceptions in the catch blocks on the stored proc exception handling), life became a lot simpler for the development team on the project. There is no reason to let the database stay secretive about its exceptions. Just throw them up to the data access layer – to provide meaningful troubleshooting info.  

An example of how to rethrow exceptions in PLSQL code is shown below (use the RAISE keyword)

DECLARE
   pe_ratio NUMBER(3,1);
BEGIN
   SELECT price / earnings INTO pe_ratio FROM stocks
      WHERE symbol = 'XYZ';  -- might cause division-by-zero error
   INSERT INTO stats (symbol, ratio) VALUES ('XYZ', pe_ratio);
   COMMIT;
EXCEPTION  -- exception handlers begin
   WHEN ZERO_DIVIDE THEN  -- handles 'division by zero' error
      INSERT INTO stats (symbol, ratio) VALUES ('XYZ', NULL);
      COMMIT

   WHEN INVALID_CURSOR THEN          dbms_output.put_line('invalid cursor');               RAISE;   WHEN INVALID_NUMBER THEN          dbms_output.put_line('invalid number');               RAISE;   WHEN ROWTYPE_MISMATCH THEN          dbms_output.put_line('rowtype mismatch');      RAISE;   WHEN TOO_MANY_ROWS THEN         dbms_output.put_line('too many rows');      RAISE;    WHEN CURSOR_ALREADY_OPEN THEN         dbms_output.put_line('cursor open');      RAISE;   WHEN DUP_VAL_ON_INDEX THEN           dbms_output.put_line('duplicate value');      RAISE;   WHEN OTHERS THEN          dbms_output.put_line('other exception');      RAISE;

END; -- exception handlers and block end here

Download Sample Solution

About the Author

Anuj Varma is a technical architect specializing in Microsoft Platforms. Along with high level design and overall architecture, he provides hands-on development, unit testing and other best practices on all the projects he works on. His troubleshooting extends to n-Tier applications, WCF and Azure based applications to advanced SQL Server performance issues.

His customer base includes DELL, Schlumberger, British Petroleum as well as several small to midsize companies across Texas. Anuj can be contacted via the contact form on his blog – http://www.anujvarma.com/

To make this work the way it did in Classic Windows – all you have to do is select Folder Options (from the Tools Menu) – and then check ‘Automatically Expand to current folder’ in the Navigation Pane checkboxes.

Step 1

Step 2

Imagine that you have just built a sophisticated application to work against a SQL Server database. You followed a best-practices approach and separated out your presentation, business logic and data access layer. Your application is service oriented – and exposes a set of services to the outside world. For e.g. – your application offers an Account Service and a Security Service for consumption by the outside world.

1. Now – you are told that this application needs to work against not just SQL Server – but Oracle as well.
2. However, the services (AccountService, SecurityService) – will be somewhat different for the Oracle version. 
3. While the services may be different, a lot of the functionality between the platforms will be similar.
4. In addition, your design must be flexible (extensible). If more database platforms were added down the road – or more services to go along with the AccountService and the SecurityServices, the design should accommodate these with minimal changes.

This can be summarized as supporting multiple services for multiple platforms (these platforms do not have to be multiple databases – can be multiple OSes, multiple device platforms –e.g. Mobile and Desktop).   One of the key issues that this design presents is that of code commonality -  and code differentiation. Some of the code for the multiple platforms may be common to both the platforms. Example – when the AccountService creates an Account, there may be exception handling code that is common to both Oracle and SqlServer. In addition – a good deal of code would be completely unique to each platform – so – a SQLServer account creation would use SQLServer authentication whereas an Oracle account creation would use Oracle specific authentication.

This article presents an architecture to solve both of the problems above (keeping common code as well as differentiation platform specific code) – and provides a full sample implementation. This implementation can be used for various problems that require accommodating multiple services and multiple platforms. The possibilities are limitless – and I have used this on at least 2 projects successfully.  It allows for extensibility by allowing more services to be added – as well as more platforms to be added down the road.

Starting Point – Make it simple for the client

What would a sample client need to do to invoke a sample platform-specific service ? Say – a client wanted to use the AccountService specific to SqlServer. The snippet below shows everything that a client should need to do – get a handle to the SqlServer factory. This factory is responsible for all SqlServer specific services – so getting an AccountService back from this factory should be as simple as a GetService call. The snippet below shows everything that a client should need to do.

An Introduction to the overall architecture

To model the various services (AccountService, SecurityService…), we notice firstly that these services are unrelated to each other. A prospective implementation could implement both the AccountService and the SecurityService.  This leads us to explore an interface based approach for the set of services.

Services by Feature (Account, Security) Architecture – An Interface Based Approach

Services By Platform (SQLServer, Oracle…) Architecture – An Inheritance Based Approach

For the platform differentiation, we note that some of the code may be common to both platforms – for e.g. – error handling and exception logging from the AccountService would need to be identical for both Oracle and SqlServer. We use an inheritance based approach – which allows us to use a Template pattern. The template pattern would provide a template method – that consists of a) Common Code b) Platform Specific Code

The Overall Architecture – using Inheritance for Platform Variation – and interfaces for services

The Service Factory

The only other component (apart from the interface based services and the inheritance based platforms) that we need is a service factory – one that will return the appropriate feature service (e.g. Account Service) – along with the appropriate platform (e.g. SqlServerAccountService).

A simple dictionary is used to store the list of services (AccountService, SecurityService…) – and a lookup method is provided as shown below:

Summary

Almost every app today follows a service oriented architecture which exposes multiple services. If our app was limited to just that, the above interface based approach coupled with our Service Factory (to return a specific service) would be all that is needed. However, today’s services are not just feature based – but also tend to support multiple platforms. These multiple platforms could be multiple databases (e.g. SQLServer and Oracle on the backend), multiple devices (e.g. Desktop and Mobile), multiple OSes etc.

This post provides a full object oriented implementation that supports multiple platforms along with multiple services (features). The multiple services were modeled using interfaces. Then, to account for the different platform implementations of each service, we defined an inheritance hierarchy – coupled with a template pattern to handle code commonality between the different platforms.

  This proves to be an elegant solution for a common, real-world problem in Object Oriented projects. There are a multitude of possible applications of the above architecture. 

Perhaps the greatest strength of the above architecture is the extensibility it provides. One can add new database platforms and new services down the road – with ease and minimal code changes.

NOTE: Ideally, you would want to design a Data Access Layer that was agnostic of the underlying database. This layer would generate all your SQL statements (CRUD) without caring about what the underlying database platform was. Such a database agnostic data access layer is described in an earlier post here.

Full Solution Download

Imagine a technology that lets you immediately response to variations in energy or water consumption – or one that allows monitoring of real-time stock data (up to 100,000 events per second). Imagine the same technology allowing monitoring of an entire manufacturing plant’s floor activities – and raising events/alerts when something goes wrong. These are just some of the applications of Microsoft StreamInsight – a powerful platform that can be used to develop complex event processing (CEP) applications.   In this post, I will provide an overview of how StreamInsight can be used to monitor IIS Log Files for events – something that can be used by high-volume, multiple server farm, asp.net websites.

Some Typical Applications of Event Driven Applications

1. Monitoring Applications
2. Analytics Applications
3. ClickStream Analysis
4. Logistics
5. Financial Trading
6. Manufacturing-  Example – Manufacturing companies require low-latency data collection and analysis of plant-floor devices and sensors. The typical manufacturing scenario includes the following requirements:

• Asset-based monitoring and aggregation of machine-born data.

• Sensor-based observation of plant floor activities and output.

• Observation and reaction through device controllers.

• Ability to handle up to 10,000 data events per second.

• Event and alert generation the moment something goes wrong.

• Proactive, condition-based maintenance on key equipment.

• Low-latency analysis of aggregated data (windowed and log-scales).

Event Driven Applications versus Database Applications

STEPS In creating an end-to-end StreamInsight application

A typical streaminsight app would need an event source, an event stream, a query to read the event stream and an output sink to handle/display the query results.

1. Define your input event source (IIS log file etc.) – and write an input adapter for it
2. Create an event stream from the event source (inputStream) that can consist of custom datatypes
3. Define the query to run against the inputStream- and start the query
4. Specify an output sink – Write an output adapter for the output sink
5. BIND the query and the output sink – and you should start seeing the output in your output file etc.

An Example – Using StreamInsight to Query IIS Log Files

If we need to query the IIS logs (txt files), then the process is as follows:

The event source would be the IIS log file – and we would write a text file adapter – which would read each line of the log file and create an ‘event’ based on the contents of the line. In addition, we can put custom datatypes inside the event (so – for e.g. – if our log file contains customer firstname, lastname as strings, you could create a ‘Customer’ datatype from these strings – and embed it inside the event).

All these events are sent as part of an ‘input stream’ which looks something like:

Now we are ready to query this stream. A simple example would be querying the stream for all customers with firstName = ‘Anuj’

Now that the query is defined, we are ready to ‘start’ the query. This essentially instantiates a ‘query’ object which stays running for the duration of the application. This effectively ‘binds’ the query to the input stream.

The only remaining step is getting the results of the query. For this, we need an ‘output’ adapter. The output can be written to a txt file, csv file etc.

Difference between SQL Server Notification Services (SQLNS) and StreamInsight

SQL Server Notification Services also works with event sources and event targets, but the similarity ends there. In SQL Notification Services, events are stored in the database and matched against subscriptions to produce notifications. The focus in SQLNS is on storing events, matching, and formatting notifications. Until the event is stored, it’s not visible to the infrastructure, only to the event provider.

In StreamInsight, the focus is on processing and querying the data in the input stream, in real-time. The stream processing architecture is lightweight, and almost all of the use cases presented in the docs name “the ability to handle up to 100,000 events per second for a large number of devices” as a goal.

Some benefits of StreamInsight

• Highly optimized performance and data throughput

  StreamInsight implements a lightweight streaming architecture that supports highly parallel execution of continuous queries over high-speed data. The use of in-memory caches and incremental result computation provide excellent performance with high data throughout and low latency. Low latency is achieved because the events are processed without costly data load or storage operations in the critical processing path. With StreamInsight, all processing is automatically triggered by incoming events. In particular, applications do not have to incur any overhead for event polling. The platform provides the functionality for handling out-of-order events. In addition, static reference or historical data can be accessed and included in the low-latency analysis.

• .NET development environment

  Developers can write their CEP applications using Microsoft’s .NET language such as Visual C#, leveraging the advanced language platform LINQ (Language Integrated Query) as an embedded query language. Given the large community of developers already familiar with these technologies, this capability reduces development costs and the time from application development to production. In the current release, StreamInsight supports only C# as the host language.

  By using LINQ, developers familiar with SQL will be able to quickly write queries in a declarative fashion that process and correlate data from multiple streams into meaningful results. The optimizer and scheduler of the StreamInsight server in turn ensure optimal query performance.

• Flexible deployment capability

  StreamInsight supports three deployment scenarios:

  • Fully integrated into the application as a hosted (embedded) DLL.

  • As a stand-alone server with multiple applications and users sharing the server. In its stand-alone configuration, the StreamInsight server runs in a wrapper such as an executable, or the server could be packaged as a Windows Service.

  • The hosted or stand-alone StreamInsight server could be part of a server farm.

• Manageability

  • The monitoring and manageability features built into the StreamInsight server provide for low total cost of ownership (TCO) of CEP applications. The management interface and diagnostic views that are provided in the StreamInsight server allow the administrator to monitor and manage the CEP application. The manageability framework also allows for ISVs and system integrators to remotely monitor and support StreamInsight-deployed systems at manufacturing and other scale-out installations.

  • StreamInsight provides a stand-alone event flow debugger that can be used to analyze, diagnosis, and troubleshoot the queries used in StreamInsight applications.
    

Real Life CEP (StreamInsight) usage Scenarios

The need for high-throughput, low-latency processing of event streams is common to the following business scenarios:

• Manufacturing process monitoring and control

• Clickstream analysis

• Financial services

• Power utilities

• Health care

• IT monitoring

• Logistics

• Telecom

The following sections discuss some of these scenarios and investigate their requirements for event processing.

Manufacturing Process Monitoring and Control

To ensure that products and processes are running optimally and with the least amount of downtime, manufacturing companies require low-latency data collection and analysis of plant-floor devices and sensors. The typical manufacturing scenario includes the following requirements:

• Asset-based monitoring and aggregation of machine-born data.

• Sensor-based observation of plant floor activities and output.

• Observation and reaction through device controllers.

• Ability to handle up to 10,000 data events per second.

• Event and alert generation the moment something goes wrong.

• Proactive, condition-based maintenance on key equipment.

• Low-latency analysis of aggregated data (windowed and log-scales).

Clickstream Analysis

An optimal customer experience from a commercial Web site requires low-latency processing of user behavior and interactions at the site. The typical click stream analysis application includes the following requirements:

• Ability to drive page layout, navigation, and presentation based on low-latency click stream analysis.

• Ability to handle up to 100,000 data events per second during peak traffic times.

• Immediate click-stream pattern detection and response with targeted advertising.

Algorithmic Trading in a Financial Services Environment

Algorithmic trading, with its high volume data processing needs, typically has the following requirements:

• Ability to handle up to 100,000 data events per second.

• Time-critical query processing.

• Monitoring and capitalizing on current market conditions with very short windows of opportunity.

• Smart filtering of input data.

• Ability to define patterns over multiple data sources and over time to automatically trigger buy/sell/hold decisions for assets in a portfolio.

Power Utilities

The utility sector requires an efficient infrastructure for managing electric grids and other utilities. These systems typically have the following requirements.

• Immediate response to variations in energy or water consumption, to minimize or avoid outages or other disruptions of service.

• Gaining operational and environmental efficiencies by moving to smart grids.

• Multiple levels of aggregation along the grid.

• Ability to handle up to 100,000 events per second from millions of data sources.

StreamInsight Server Architecture

The run-time component of Microsoft StreamInsight is the StreamInsight server. It consists of the core engine and the adapter framework. The adapter framework allows developers to create interfaces to event stores such as Web servers, devices or sensors, and stock tickers or news feeds; and to event sinks such as pagers, monitoring devices, KPI dashboards, trading stations, or databases. Incoming events are continuously streamed into standing queries in the StreamInsight server, which process and transform the data according to the logic defined in each query. The query result at the output can then be used to trigger specific actions.

The following illustration presents a high-level overview of the StreamInsight architecture.

Conclusion

Using Microsoft’s StreamInsight platform for complex event processing, one can develop robust event-driven applications with high-performance and scalability. This post was meant to serve as an overview of the capabilities of the technology – and also provide a real-life example (querying IIS log files across a server farm) using StreamInsight.

References : Raising Events from a PUSH Source

http://blogs.msdn.com/b/masimms/archive/2010/08/10/building-your-first-end-to-end-streaminsight-application.aspx

This was the second time I got tennis elbow. The first time, like others out there – I tried everything from physiotherapy to miracle ointments to pain killers – and learnt the hard way what works and what doesn’t. The first time – it took me 6 months – including LOTS of physiotherapy to get over it. The second time, it took me less than 3 weeks – and zero physiotherapy. I just knew what exercises to do – and what things to avoid. This article summarizes everything I did during those 2-3 weeks – and also everything that I continue to do on a preventative basis.

Intuitive Recovery Time

At an intuitive level, when one is unable to even pick up small objects (or open doors), one feels that one may never recover (or at least, that it is going be a super slow process). This is exactly how I felt.

Actual Recovery Time

I was able to work on my computer within a week – and actually made a full recovery in less than 3 weeks – but I had to do a LOT of things right. Had I not done any of these things, I doubt if my recovery would be as quick.

Step 1 – Think that you have the flu (Limit your movements)

When you are down with something bad – like the flu – do you think about going to work? Or sitting on your computer? Or doing anything except lying down? Well – that is how you must treat your tennis elbow. Except – you do not have to be bed confined. But you do have to limit your movements – especially movements that involve your hands. I cut down on my driving – and only drove short distances (that too with elbow braces (see below) always around my forearms). Goes without saying that – tennis, golf etc. are all taboo. Lifting anything remotely heavy is out of the question. You have a serious ailment – and you need to treat it as such. This is one of those obstinate things that will just not go away if you do not give it complete rest (see step 2 below).

Step 2 – Wear an elbow brace 24/7 (except while sleeping)

My orthopedic explained the importance of this brace. Anything that you do with your hands – is connected to the same, common tendons in your elbow. This is why even a small action such as opening a door – hurts like hell. The idea is to arrest all hand motion from reaching the elbow – and the brace helps do just that. Without it – your elbow never really gets rested – and even the slightest hand motion keeps injuring it further.

These braces need to be worn even after your elbow starts improving. For a period of at least 6 months. Let the brace become part of your fashion statement – don’t worry about how it looks or whether it feels warm etc. Just wear it – otherwise chances are you will end up with a relapse (in my case, I believe this WAS a cause of the relapse – I started feeling better – and started doing things without the brace. Bad idea – just wear the brace at all times).

1. Imak Elbow Band

2. Medspec Tennis Elbow Support

If you can afford to put your affected arm in a sling – do so. That is the ultimate rest for the elbow.

Step 3 – Do Forearm/Elbow stretching exercises – ALL DAY LONG

If you want your elbows, hands and forearms to get strong – you must do a specific set of exercises. And do these as often as you can. The three sets of exercises that I did religiously included:

1. Resistance Band (Stretch Band) Exercises – This was recommended to me by a top physiotherapist (this guy treats some of the top athletes – tennis players, soccer players etc.).  Just tie one end to a staircase knob or any other solid support – and grasp the other end in your affected hand.

Stretch 1 – Straight Back elbow stretches – holding your end of the band at about belly-button height. Stretch it straight back – so your elbow moves past your hip – and hold for at least 10 seconds. Keep increasing the time you can hold it.

Stretch 2 – Diagonally across elbow stretches. Hold your end again at belly button height. Now try and stretch it diagonally across your chest towards your opposite shoulder (if you are holding it in your right hand – move towards your left shoulder).

How often should you do them? At a minimum – twice a day – but as often as you can is ok. My physiotherapist (who taught me these stretching exercise) – said you cannot do enough of these.

2.  Theraband Twisting – This was something I tried on my own (as opposed to the resistance band which my physiotherapist recommended). The theraband comes in various ‘flexes’ – I got the ‘light’ – and that was good enough. I have heard the medium can be a little hard for seriously affected elbows. There are several youtube videos on tennis elbow theraband exercises.

How often should you do them? At a minimum – twice a day – but I did these more than twice – based on the advice of my physio about the stretch band exercises.

3.   Tennis Ball Squeezing

In an ironic twist, the thing that causes tennis elbow (tennis) – can also help in the recovery process. Just hold a regular tennis ball held in your palm – and squeeze it as hard as you can. Initially, you will find this to be difficult – since your hand will have very little strength. As you do this more and more – you will find your grip getting stronger. This is the simplest and one of the more effective exercises that I did. I carried that ball everywhere (I didn’t care if other lunch folks saw me squeezing a tennis ball while waiting for my food..). Again – like the rest of the exercises – there is no limit to how often you do this. As much as possible!

Exercises Summary

I am sure there are dozens of other recommended exercises (wrist flex with small weights, hold out your palm and flex it upwards/downwards). These are all worth doing – in addition to the ones above. The ones I have listed above (the stretch band exercises especially) – were shown to me by a really good physiotherapist (some famous sportspeople go this guy for their injuries). I take these exercises to be the most important of the lot. The theraband was something I tried on my own – and it seemed to help as well (it comes with its own instructions – but you can youtube theraband exercises for tennis elbow).

How often should you do them? At a minimum – twice a day – but as often as you can is ok. My physiotherapist (who taught me the stretching exercise) – said you cannot do enough of these. In case you are worried that you may be ‘over working’ an already inflamed elbow – you would be wrong. These stretches actually help the elbow recover. Something as simple as trying to squeeze a tennis ball builds hand strength and wrist strength. These exercises were the centerpiece of my recovery program – and I am convinced that without these – my recovery would have taken longer.

Step 4 – Homeopathic medicines

I grew up in India – and have seen these little pills work magic on all kinds of ailments. They work on a somewhat similar principle to vaccines – where you introduce a minute quantity of something that causes your body’s immune system to spring into action. The best thing about these medicines is that they have no side effects whatsoever.  The specific items that I took for tennis elbow (on the recommendation of an excellent homeopathic doctor) were :

1. Hypericum Perforatum 200 C

  2. Symphatum 200 C

Alternate these two medicines every 3 hours. Within a week you should see some relief. Continue taking these for a total of 3 weeks. (These are easily available at whole foods or other natural grocery stores – as well as online).

Step 5 – Change your keyboard, mouse

Tennis elbow is caused by repetitive stress. Computer typing is one of the most common forms of this type of stress. In my case, it was at least partly responsible for my tennis elbow (besides actual tennis and golf). Once you have regained some strength – consider getting a keyboard and mouse that is as ‘soft’ as possible.

The keyboard I settled on (after trying a lot of them) – is the HP Elite Keyboard.

The mouse I settled on was the Microsoft Arc Touch Mouse.

They both continue to serve me well – and are very soft to the touch.

Things that did not work

Thanks to the internet, I got to try virtually every “miracle-cure” that my friend, Google could suggest. I was desperate to get better fast – and while I did eventually get better, I learnt a lot about what worked for me and what did not.

1. Ointments, Penetrex etc. – Penetrex is the highest rated product on amazon.com for treating tennis elbow. I must have rubbed four jars full. Did not make the slightest difference as far as I could tell. Not saying it does not work for others – just did not work for me. Also – as an alternative, I tried Capsaicin – WHICH ACTUALLY HELPED. It is the only ointment/topical pain reliever that made the slightest bit of difference. I would apply it at least twice a day on both my elbows. Be sure to start with a small concentration (0.035) – this small dosage burnt a bit – so I can only imagine how much the 0.1 (high potency) would burn. Good news is that I found the small concentration (0.035) to be very effective – so did not have to try the higher concentration.

   2. Advil, Tylenol etc. – These had the least effect in terms of actually helping the tennis elbow. They may mask the pain temporarily – but this can be a bad thing – since you start ‘doing more’ with your arms – leading to further aggravation of the condition. I stopped taking all pain killers (and stuck to the homeopathic medicines above – which have no side effects).

   3.  Prolotherapy – There is a lot of discussion about the effectiveness of this for tennis elbow. I tried it – it did not work. This was the most expensive thing I tried (cost $500) – but it did nothing to relieve my pain.

Long Term – Continued Prevention

Steps 2 (wearing elbow braces),  3 (stretching exercises) – and 5 (use softer keyboards, mice) – are a must on an ongoing basis – if you want to avoid a relapse of the condition.

Summary

As I mentioned before, everyone’s experience of what works and what doesn’t may differ. This is just my own experience. Having suffered from tennis elbow TWICE (in quick succession) – and having tried everything from ointments, pills, lots of physiotherapy, prolotherapy, home exercises to homeopathic medicine, I have learnt what works for me. If you are suffering from this serious condition, I feel for you – and wish you a quick recovery. Hopefully, something from this post would be helpful to you.  While I have listed these sequentially (Step 1….6), obviously, they all need to be done in parallel. Each step is an important part of the recovery process – and trust me, if you take this condition lightly, it WILL get the better of you.

Here is a quick recap of the ‘goodie bag’ (of things that worked).

Imak Elbow Band: Health & Personal Care ASIN: B0014WXF8M	Continue to wear throughout the day  – even after your elbow starts to recover. Wear for 6 months (advice of my ortho and my physiotherapist).
Valeo Stretch Bands: Sports & Outdoors ASIN: B0007IS714	Do the ‘straight back’ and ‘diagonally across’ stretches every day – as often as you can (minimum twice a day). Continue doing even after your elbow recovers.
Capzasin-P Topical Analgesic Cream, .035-Percent Capsaicin, 1.5-Ounce Tubes (Pack of 3): Health & Personal Care ASIN: B001G7QGC2	Apply over the sensitive elbow – at least twice a day – or whenever the pain gets bad. Use the low concentration – 0.035 – to begin with. This worked for me.
Boiron Hypericum Perforatum 200C 75 pellets: Health & Personal Care ASIN: B0006NXGF2	Take this medicine and the one below – alternating every three hours. 5 pellets each is the dosage on each dose (but read your particular bottle to double-check).
Boiron Symphytum Officinale 200C 75 pellets: Health & Personal Care ASIN: B0006NXGQ6
Microsoft Arc Touch Mouse (Black): Electronics ASIN: B003UT6C9G	Get rid of your old mouse – and use this or something similar which has soft touch – and touch based scrolling.
HP Wireless Elite Keyboard V2: Electronics ASIN: B005HNHRA6	This is the softest ever keyboard – apart from having a touchscreen (like the Ipad) this is the least strain on my typing fingers.
	Hold this in your palm – and squeeze as hard as you can. Slowly, as you regain strength, you will be able to squeeze harder.

What does this have to do with Yoga?

Too often, we just show up on our mat – without really having a ‘purpose’. We figure – this is an instructor led session – I’ll let the instructor do the leading. And we go through the motions, However, I believe that to get the most of a session, one needs to come into each session with a mindset- analogous to a golf swing thought.

This mindset is referred to (by one of my yoga instructors) as your ‘intention’. Figure out what your intention is before you get on your mat.

Two swing thoughts (intentions) that have worked for me:

• Strong with breath – I like to think of myself as growing strong with each breath I take.  I try to ‘feel strong’ even though it may not start out that way. As I keep telling myself ‘I am strong’ – I realize that I am able to hold the poses longer – and with more resolve. This is a great thought  – and works well for most yoga sessions (except ones where I am really out of it – and feeling somewhat weak).
• Entire body as one connected block (e.g. slab of wood) – This is a curious swing thought – and one that works well when it does. What happens is that as I stretch different parts of my body, I realize that I am just moving those parts – independent of the rest of the body. The waist may be twisting – but my hips and legs are not involved. Then – I start visualizing my entire body as one continuous slab of wood. This helps me realize the ‘connectedness’ of every part of the body.  NOW – each stretch I do – involves the entire body – moving as one piece. This helps me feel stronger through the practice.

Hope those two thoughts (or any of them) work for you. If you have a favorite thought that you take into your yoga practice session, please do share it via comments on this post.

Namaste!

.NET 4.0 introduces IObservable (Publisher) and IObserver (Subscriber). These interfaces were long overdue – for a couple of reasons:

1. The ubiquitous nature of the Publish Subscribe pattern.
2. The cludgeability of implementing these using events and delegates. Prior to these, one had to build a publish subscribe solution using events and delegates. This came with its own set of gotchas.
3. Even a WCF Publish Subscribe  implementation could not get away from explicitly publishing ( using events ) and subscribing ( using event handlers)

And while these new interfaces will not save you the effort of an actual implementation, they provide a standard template for implementing the publish subscribe pattern in .NET. This article provides:

1. A simple, starting implementation of these two interfaces.
2. As a second step, to illustrate a real-world usage of the sample implementation, a MagazinePublisher class is defined. This class maintains a list of all magazine subscribers – and notifies them whenever a new issue is available.

This sample application (full source code available below) can be used as a starting point for any publish subscribe application.

The ‘Publisher’ Interface

1. In these new interfaces, the Publisher goes by the name Observable.
2. Two primary responsibilities of the Publisher are:

a) Subscription and Unsubscription (Adding and Removing subscribers)

b) Notification (of all subscribers)

Subscription and Unsubscription

The implementation of IObservable(T) contains a subscribe method – which returns an instance of the RemoveMe class (which implements the IDisposable interface). This ensures that subscribers can call Dispose() when they are ready to unsubscribe.

Notification

Notify can be called to notify all observers that there are changes in the observed object.

The Subscriber

Now that we have successfully described the two main responsibilities of the Publisher, we are ready to look at a sample Subscriber. The only thing a Subscriber needs to do is implement the IObserver<T> interface – using the Publisher as the type T that it is observing. This is a particular simple approach – even though it somewhat couples the subscriber to a specific publisher type.

Since the Publisher instance is passed in to the OnNext method, it is easy to retrieve all Publisher specific info in the subscriber. This example shows a subscriber getting notified of a new issue – and printing out the month of the issue.

Tying the Subscriber to the Publisher

This is the last step in our sample solution – now that we have both the Subscriber and the Publisher completely defined, we can use them in a simple program.

Summary

There are several advantages of using these new interfaces to use in your own publish subscribe solution.

1. Consistency, Uniformity – Everyone’s Publish Subscribe will now look the same – a great time-saver for new people brought onto a project.
2. Moving away from events delegates –While events and delegates are great-  and can be used to provide the same implementation as the one above, one needs to be extra careful in removing (unsubscribing) from subscribed events. There are also a few other ‘gotchas’ in a typical publish subscribe pattern (that are discussed in detail here).

It isn’t everyday that one gets excited about the introduction of a couple of new interfaces – but given the ubiquitous applicability of the Publish Subscribe (or Observer) pattern, this is a fairly big deal. The only thing I disliked was the naming of the two interfaces – it leads to confusion. Which is why this article continues to refer to them as Publisher (IObservable) and Subscriber (IObserver).

Full Solution

Note – To compile successfully, your target framework must be set to .NET 4.0  (Right click the project properties and set the target framework). If you haven’t already, I would recommend using Visual Studio 2011 (beta) available here.

Solution

The browse server functionality uses the RDS server in Cold Fusion. I wish they would display a huge warning during installation to warn users that without RDS, they will be unable to do a lot of tasks which they could in the previous versions (previously RDS ran as a separate windows service – and was NOT required to add datasources to your Cold Fusion administrator). Be that as it may, enabling RDS is a simple matter to two tweaks to your web.xml file (under ColdFusion9\wwwroot\WEB-INF). Simple open up this file – and look for RDS. You will find two occurrences – both of them commented out – like the one shown below:

<!– begin RDS
   <servlet id=”coldfusion_servlet_8789″>
       <servlet-name>RDSServlet</servlet-name>
       <display-name>RDS Servlet</display-name>
       <servlet-class>coldfusion.bootstrap.BootstrapServlet</servlet-class>
       <init-param id=”InitParam_103401311065856789″>
           <param-name>servlet.class</param-name>
           <param-value>coldfusion.rds.RdsFrontEndServlet</param-value>
       </init-param>
   </servlet>
end RDS –>

Just uncomment these two occurrences, save  your web.xml and restart the Cold Fusion server. That should allow you to browse your server  – and add datasources to your cold fusion administrator

The 32 bit ODBC driver panel

It turns out that those drivers are available via a DIFFERENT odbc control panel – the 32 bit one. The default ODBC control panel is the 64 bit one – and does not list any of the older, 32 bit drivers.

To get to the older drivers, you have to fire up this odbcad32.exe – found under the folder  C:\Windows\SysWow64.

Once you launch this panel, you should see all your old friends again.