C# turns out to be cool

When I was in college, one of the things I did with great enthusiasm was to pick up Core Java , through my own pet projects and programs.
In many ways it was really a foundation layer of what was to become my career & a cool intro the real world of software engineering . It
was object oriented, it was easy to come up with UI using Swing , and I didn’t have to scratch my head too much for pointers . I had written
a lot of standalone C++ programs, but the thought of coming up with some worthwhile software in the unmanaged realm of C++ is something
 have yet to burn my fingers with. Java, with its JVM-managed-show, its easy to pinpoint errors by trailing thru the stacktraces . But for things
I love most, anything computationally intensive like image manipulation or anything intensive in number crunching, it just fails horribly when
it comes to speed. I’m not throwing out statistics in the milliseconds here because I’ve never really got to measuring that far, the time lag is
perveivably in seconds and even minutes – for image manipulation. I last worked in the software division of an investment bank, where a lot
of calculation intensive code was actually written in Java, and a lot of time was spent in trying to ‘reduce latency’ and reduce the time taken
for calculations. Maybe a lot of the problems could have been solved by not using Java. Even though it has been a kind of first love for me
over the last couple of years .
Anyways now coming to C# – I had get myself to learn it now that I was at Microsoft. Syntactically it was very similar to Java, so it didn’t come
as a total shock to me. But I think the best thing was that I could really put to use the unsafe code structure for running things in an unmanaged
native environment with basic knowledge of pointers from C. So for boring things like UI stuff – I can normal C# Code , but wherever I need low
level access I just use unsafe code! Images which can’t be processed in less than say 10 secs in Java can now be processed in the order of 100
milliseconds or so which is just great. When it comes to an image manipulation , even a 1024×640 image requires that many transitions between
 the managed environment and native code, which obviously takes a lot of time. Moral of the story : C# trurns out to be just great for me ->
don’t need to make a transition to C++ altogether and I get the best of the both the worlds of Java and C !
This entry was posted in Uncategorized. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s