சுதந்திரம்

அன்று சிலர் குண்டை மார்பில் ஏந்தினர் 

பலர் சுதந்திரம் பெறுவதற்கு 

இன்று சிலர் குண்டை கையில் ஏந்தினர் 

பலர் சுதந்திரம் இழப்பதற்கு 

என்று இந்த சமுதாயம் திருந்துமோ! இல்லையேல் 

அவர்களால் அனைத்தும் அழியுமோ!!

காவிரியை காப்போம்!

தென்னையின் நீரென சிறுஊற்றில் பிறந்தாய்

தமிழன்னையின் சேயென தரணியில் வளர்ந்தாய்

பெண்மையின் அன்பை ஊரெலாம் பொழிந்தாய்

கணவனான கடலில் கவின்மிக கலந்தாய்

இடையில் பல இன்னல்களும் இருந்தன.

பெண்மையின் இருப்பிடமாய் பேருருகொண்ட உன்னை

பேதைகள் பலர் பெருமுயற்சியால் தடுத்தனர்

இவ்வன்னை மடியில் வளரத் தடைபல

அத்தடைகளை கோபம் கொண்டு உடைக்கவில்லை

பெண்மையின் அங்கமே பொறுமை ஆதலலோ ?

உன்னை மீட்க பொறுமையுடன் போரிடுகிறோம்

உன்னால் வளர்ந்ததெங்கள் எண்ணங்கள் ஆதலால்

பொலிவுடைய பொன்னி என்னும் பெண்ணே

எங்களை பேணும் உன்னை வளபடுத்துவோம்  

நீ வளரும் காலம் வெகுஅருகில்.

செவ்வந்தி!

செவ் 'அந்தியில்' பூக்கும் செவ்வந்தியே!
இருளில்தான் உனது வாழ்க்கை என்பதை அறிவாயோ?
மாலையில் மலர்ந்து சிரிக்கிறாய்! சிலிர்க்கிறாய்!!
பின்னே புரிந்தது மாலையின் துயரம். 

உடனுறை மலர்களால் உள்ளம் பூத்தாய்,
தோழர்கள் மணத்தால் மாலையில் சேர்ந்தனர் - மாலையில்!
உன்னிலை என்ன? நீ அறிவாய்!
தனிமையில் நீ!  துணையாய் தனிமை!!

முன்காலையில் வந்தவர் முழுவதுமாய் கொய்தார்.

அந்த அற்பமகிழ்ச்சியும் அரைமணி நேரம்தான் அறிவாயோ?

உயர்ந்ததோர் மாலையாய் உனையும் வடித்தார்.
உயர்ந்தது உவகை உந்தன் உள்ளத்தில்!  

நெடுமையாய் கிடந்தவன் தலையை தூக்கி
உற்றதோர் மலையாய் உனையே மாட்டினர் அவ்வுருவத்திற்கு.
கண்ணீரும் பன்னீரும் உந்தன் மேலே
அவை உனதோ? உற்றவர் உடையதோ?

சடுதியில் விழுந்தாய்! புழுதியில் மடிந்தாய்!!

இடுகாடு வழியிலேயே இறுதி முடிவு உனக்கு.
உனது சோகங்கள் அதோடு மடிந்ததோ?

மடிந்த இடத்தில்தான் மறுபடி முளைத்ததோ?

நெடுவழி சென்றவருக்கு வழித் துணையானேன்,
பெருந்துயர் நீங்கி உயர்நிலை அடைந்தேன் உன்னதமாய்!
பெரும்பயன் அளித்ததே பெருமை! பெருமை!!

செருக்குடன் மகிழ்ந்து மடிந்தது செவந்தி!

OOTY in My Cam

 

பயணம்

அவன் பயணப்பட்டான். வாழ்க்கை களத்தில் அவன் பயணம் இன்னும் முடியவில்லை. முன்னோக்கி பார்த்தான் அவன். பாதை பிடிபடவில்லை. அவன் பின்னோக்கி திரும்பியதுதான் தாமதம். கொடிய விலங்குகள் அவனை ஆட்கொள்ள வந்துகொண்டிருந்தன.

அந்த கொடிய விலங்குகள் அவனது நினைவுகள்தான்.  பாதையின் பல இடங்களில் சந்தித்து வந்தவைதான்.  என்றாலும் அவன் மனம் துவண்டது.  போராடியபோது ஏற்பட்ட வலியை இப்போதும் உணர்ந்தான் அவன்.  அவை பின்தொடர்வதை அவனால் தடுக்க முடியவில்லை.  அவன் பலமுறை இவ்வாறு பின்னோக்கி பார்த்ததுண்டு.  அவனை பின்தொடர்ந்தவைகளின் எண்ணிக்கை கூடியதே தவிர குறையவில்லை. சில நேரங்களில் பயந்ததுண்டு. ஆனாலும் அவன் தன் பயணத்தை தொடர்ந்தான். 

அவனது இன்பப்பூக்கள் எங்கே என்ற நினைவு அவனுக்கு வந்தது. அவற்றை காண ஆவலாய் திரும்பினான். அதோ தூரத்தில் சில புள்ளிகளாய் அவை அவனுக்கெதிர்திசையில் நகர்ந்துகொண்டிருந்தன.  அவன் கண்களின் ஈரம் அவற்றை வளர்க்குமா? என்ற ஏக்கம் அவனுக்கு வந்தது.  சில மிருகங்களிடமிருந்து காத்து வருடிய பூக்களாயிற்றே அவை.  தன்னை காத்த ஆயுதங்களாய் கண்டான் அவன். சில இடங்களில் துவண்டாலும் பல இடங்களில் காத்து பயணத்தை தொடரச்செய்தது. 

அவனே அவனை கடிந்து கொண்டான். பின்னோக்கியபடி பயணத்தை தொடர்வது தவறு என முன்னோக்கினான்.  பாதை இருள்சூழ்ந்திருந்தது.  இப்போது அவனுக்கு பயமில்லை. பாதை இருளாக இருந்தாலும் சேரவேண்டிய இடம் ஒளிப்பிழம்பாய் தெரிந்தது.  அவனது கால்கள் அந்த ஒளிப்பிழம்பை நிலையாய் கொண்டு நகர்ந்தன. 

அவனது பயணம் தொடர்கிறது.

Application Development Foundation - Part 3

Using Common Reference Types

Most types in the .NET Framework are reference types. Reference types provide a great deal of flexibility, and they offer excellent performance when passing them to methods. 

Reference types store the address of their data, also known as a pointer, on the stack. The actual data that address refers to is stored in an area of memory called the heap.

The runtime manages the memory used by the heap through a process called garbage collection. Garbage collection recovers memory periodically as needed by disposing of items that are no longer referenced.

Reference types represent the address of data rather than the data itself, assigning one reference variable to another doesn't copy the data. Instead, assigning a reference variable to another instance merely creates a second copy of the reference, which refers to the same memory location on the heap as the original variable.

Common Reference Types

Type	Use for
System.Object	The Object type is the most general type in the Framework. You can convert any type to System.Object, and you can rely on any type having ToString, GetType, and Equals members inherited from this type.
System.String	Text data.
System.Text.StringBuilder	Dynamic text data.
System.Array	Arrays of data. This is the base class for all arrays. Array declarations use language-specific array syntax.
System.IO.Stream	Buffer for file, device, and network I/O. This is an abstract base class; task-specific classes are derived from Stream.
System.Exception	Handling system and application-defined exceptions. Task-specific exceptions inherit from this type.

String and String Builder

System.String are immutable in .NET. That means any change to a string causes the runtime to create a new string and abandon the old one.

StringBuilder class to create dynamic (mutable) strings.  The StringBuilder solution is the most flexible because it can span multiple statements. The default constructor creates a buffer 16 bytes long, which grows as needed. You can specify an initial size and a maximum size if you like.

Throw and Catch Exceptions

Exceptions are unexpected events that interrupt normal execution of an assembly. For example, if your assembly is reading a large text file from a removable disk and the user removes the disk, the runtime will throw an exception. This makes sense because there is no way your assembly could continue running.

Exceptions should never cause your assembly to fail completely. Instead, you should plan for exceptions to occur, catch them, and respond to the event. In the preceding example, you could notify the user that the file was not available, and then await further instructions from the user.

Syntax for Try Catch

' VB
Try
    ' coding

Catch ex As Exception
    ' If there are any problems reading the file, display an error message

Finally

' Finally block

End Try

In the preceding example, if any type of error occurs—including a file not found error, insufficient privileges error, or an error during the reading of the file—processing continues within the Catch block. If no problems occur, the runtime skips the Catch block.

Note:

The runtime will execute only the first Catch block with a matching exception type, however, so order Catch blocks from the most-specific to the least-specific.

The Finally block runs after the Try block and any Catch blocks have finished executing, whether or not an exception was thrown. Therefore, you should use a Finally block to close any streams or clean up any other objects that might be left open if an exception occurs.

Application Development Foundation - Part 2

Using Value Types

• The simplest types in the .NET Framework, primarily numeric and Boolean types, are value types.
• Value types are variables that contain their data directly instead of containing a reference to the data stored elsewhere in memory.
• Instances of value types are stored in an area of memory called the stack, where the runtime can create, read, update, and remove them quickly with minimal overhead.

There are three general value types:

• Built-in types
• User-defined types
• Enumerations

Built-in types

Type (Visual Basic/C# alias)	Bytes	Range	Use for
System.SByte (SByte/sbyte)	1	-128 to 127	Signed byte values
System.Byte (Byte/byte)	1	0 to 255	Unsigned bytes
System.Int16 (Short/short)	2	-32768 to 32767	Interoperation and other specialized uses
System.Int32 (Integer/int)	4	-2147483648 to 2147483647	Whole numbers and counters
System.UInt32 (UInteger/uint)	4	0 to 4294967295	Positive whole numbers and counters
System.Int64 (Long/long)	8	-9223372036854775808 to 9223372036854775807	Large whole numbers
System.Single (Single/float)	4	-3.402823E+38 to 3.402823E+38	Floating point numbers
System.Double (Double/double)	8	-1.79769313486232E+308 to 1.79769313486232E+308	Precise or large floating point numbers
System.Decimal (Decimal/decimal)	16	-79228162514264337593543950335 to 79228162514264337593543950335	Financial and scientific calculations requiring great precision
System.Char (Char/char)	2	N/A	Single Unicode characters
System.Boolean (Boolean/bool)	4	N/A	True/False values
System.IntPtr (none)	Platform-dependent	N/A	Pointer to a memory address
System.DateTime (Date/date)	8	1/1/0001 12:00:00 AM to 12/31/9999 11:59:59 PM	Moments in time

Note:
When you assign between value-type variables, the data is copied from one variable to the other and stored in two different locations on the stack.

User defined type

User-defined types are also called structures or simply structs, after the language keyword used to create them. As with other value types, instances of user-defined types are stored on the stack and they contain their data directly. In most other ways, structures behave nearly identical to classes.

[vbnet]
Structure <struct-name>
      'Body of structure
End Structure

[csharp]
public struct <struct-name>
{
      //Body of strucrue
}

Structures are a composite of other types that make it easier to work with related data. The simplest example of this is System.Drawing.Point, which contains X and Y integer properties that define the horizontal and vertical coordinates of a point.

The structure can contain fields, methods, constants, constructors, properties, indexers, operators and even other structure types.

There is no inheritance for structs as there is for classes. A struct can't inherit from another struct or class and it can't be the base class for a class. But remember that in .NET all types are directly or indirectly inheriting from the super base class object and hence the structure also. Since structs doesn't support inheritance, we can't use the keywords virtual, override, new, abstract etc with a struct methods. .NET struct types are never abstract and are always implicitly sealed. The abstract or sealed modifiers are not permitted in a struct declaration. 

Enumerations

Enumerations are related symbols that have fixed values. Use enumerations to provide a list of choices for developers using your class. For example, the following enumeration contains a set of titles:

' VB
Enum Titles As Integer
    Mr
    Ms
    Mrs
    Dr
End Enum

// C#
enum Titles : int { Mr, Ms, Mrs, Dr };