Heard it somewhere!

The world it seems, is moving towards an age where an intellectual person will be judged based on the blog posts per week he writes, the tweets he generates (or regenerates) per day, the number of new jargons demystified or created by him per minute and the number of questions he answers per second on stackoverflow.com (think before you rule out the possibility of such a world in near future). To validate myself as a deserving citizen of that world (as and when it comes to existence), I went ahead to demystify certain words and phrases which the gigantic personas of technology in general (credit for the inspiration of this post should go to Erik Meijer, Anders Hejlsberg, Scott Hanselman, Scott Guthrie and so many more who couldn't be declared for genuine space constraints), often use without even considering the fact that some of their audience (read me and only me) have no idea of what that word or phrase corresponds to.

This is an attempt to collate certain phrases which most of us have heard numerous times but haven't essentially researched our way into understanding them comprehensively.

• Domain Specific Language (DSL): It's a programming or specification language dedicated to a particular problem domain or a particular problem representation technique. The concept isn't new—special-purpose programming languages and all kinds of modeling/specification languages have always existed, but the term has become more popular due to the rise of domain-specific modeling. Examples of domain-specific languages include Logo for children, spreadsheet formulas and macros, SQL for relational database queries, YACC grammars for creating parsers, regular expressions for specifying lexers.
• Mashup (Web application hybrid): In web development, a mashup is a web page or application that uses or combines data or functionality from two or many more external sources to create a new service. The term implies easy, fast integration, frequently using open APIs and data sources to produce enriching results that were not necessarily the original reason for producing the raw source data. In the past years, more and more web applications provide APIs that enable software developers to easily integrate data and functions instead of building it themselves. Mashups can be considered to have an active role in the evolution of social software and Web 2.0. The term mashup is also used to describe a remix of digital data.
• Cloud computing: It is Internet-based computing, whereby shared resources, software and information are provided to computers and other devices on-demand. It is a paradigm shift following the shift from mainframe to client–server that preceded it in the early 1980s. Details are abstracted from the users who no longer have need of expertise in, or control over the technology infrastructure "in the cloud" that supports them. Cloud computing describes a new supplement, consumption and delivery model for IT services based on the Internet, and it typically involves the provision of dynamically scalable and often virtualized resources as a service over the Internet. It is a byproduct and consequence of the ease-of-access to remote computing sites provided by the Internet.
  The term "cloud" is used as a metaphor for the Internet, based on the cloud drawing used in the past to represent the telephone network, and later to depict the Internet in computer network diagrams as an abstraction of the underlying infrastructure it represents. Typical cloud computing providers deliver common business applications online which are accessed from another web service or software like a web browser, while the software and data are stored on servers.
• Atom: It is an alternate XML format for easily sharing content, much like RSS Really Simple Syndication (format). Blogs for example, publish Atom feeds. Atom and RSS have very similar uses; the motivation behind Atom sprang from a desire to add improvements to the RSS specification. Apparently the keeper of the RSS specification froze the spec (declaring that RSS 2.0 would be the last version) and so the authors of Atom felt that a new format was necessary.
• OAuth and OpenId: OAuth is a simple way to publish and interact with protected data. OAuth attempts to provide a standard way for developers to offer their services via an API without forcing their users to expose their passwords (and other credentials). OAuth is not an OpenID extension and at the specification level, shares only few things with OpenID – some common authors and the fact both are open specification in the realm of authentication and access control. If OAuth depended on OpenID, only OpenID services would be able to use it, and while OpenID is great, there are many applications where it is not suitable or desired. OAuth talks about getting users to grant access while OpenID talks about making sure the users are really who they say they are.
• OData: The Open Data Protocol (OData) is a Web protocol for querying and updating data that provides a way to unlock your data and free it from silos that exist in applications today. OData does this by applying and building upon Web technologies such as HTTP, Atom Publishing Protocol (AtomPub) and JSON to provide access to information from a variety of applications, services, and stores. The protocol emerged from experiences implementing AtomPub clients and servers in a variety of products over the past several years.  OData is being used to expose and access information from a variety of sources including, but not limited to, relational databases, file systems, content management systems and traditional Web sites.
• Mixin: In object-oriented programming languages, a mixin is a class that provides a certain functionality to be inherited by a subclass, while not meant for instantiation (the generation of objects of that class). Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. Mixins encourage code reuse and avoid well-known pathologies associated with multiple inheritance. However, mixins introduce their own set of compromises. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixin's attributes and methods. They become part of the class during compilation. Interestingly enough, mixins don't need to implement an interface. The advantage of implementing an interface is that instances of the class may be passed as parameters to methods requiring that interface. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. This differs from the most widely-used approach, which originated in the programming language Simula, of defining all attributes, methods and initialization at compile time.
• Monads: A monad is a construction that, given an underlying type system, embeds a corresponding type system (called the monadic type system) into it (that is, each monadic type acts as the underlying type). This monadic type system preserves all significant aspects of the underlying type system, while adding features particular to the monad. In functional programming, a monad is a kind of abstract data type used to represent computations (instead of data in the domain model). Monads allow the programmer to chain actions together to build a pipeline, in which each action is decorated with additional processing rules provided by the monad. Programs written in functional style can make use of monads to structure procedures that include sequenced operations, or to define arbitrary control flows (like handling concurrency, continuations, or exceptions). Formally, a monad is constructed by defining two operations (bind and return) and a type constructor M that must fulfill several properties to allow the correct composition of monadic functions (i.e. functions that use values from the monad as their arguments). The return operation takes a value from a plain type and puts it into a monadic container of type M. The bind operation performs the reverse process, extracting the original value from the container and passing it to the associated next function in the pipeline.
• Type Safety: In computer science, type safety is the extent to which a programming language discourages or prevents type errors. A type error is erroneous or undesirable program behaviour caused by a discrepancy between differing data types. Type safety is sometimes alternatively considered to be a property of a computer program rather than the language in which that program is written; that is, some languages have type-safe facilities that can be circumvented by programmers who adopt practices that exhibit poor type safety. The formal type-theoretic definition of type safety is considerably stronger than what is understood by most programmers. Type enforcement can be static, catching potential errors at compile time, or dynamic, associating type information with values at run time and consulting them as needed to detect imminent errors, or a combination of both. Type safety is closely linked to memory safety, a restriction on the ability to copy arbitrary bit patterns from one memory location to another. For instance, in an implementation of a language that has some type t, such that some sequence of bits (of the appropriate length) does not represent a legitimate member of t, if that language allows data to be copied into a variable of type t, then it is not type-safe because such an operation might assign a non-t value to that variable. Conversely, if the language is type-unsafe to the extent of allowing an arbitrary integer to be used as a pointer, then it is clearly not memory-safe.
• Immutable Objects: In object-oriented and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. An object can be either entirely immutable or some attributes in the object may be declared immutable; for example, using the const member data attribute in the C++ programming language. In some cases, an object is considered immutable even if some internally used attributes change but the object's state appears to be unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object. The initial state of an immutable object is usually set at its inception, but can also be set before actual use of the object. Immutable objects are often useful because some costly operations for copying and comparing can be omitted, simplifying the program code and speeding execution. However, making an object immutable is usually inappropriate if the object contains a large amount of changeable data. Because of this, many languages allow for both immutable and mutable objects.
• Thread safety is a computer programming concept applicable in the context of multi-threaded programs. A piece of code is thread-safe if it functions correctly during simultaneous execution by multiple threads.
  Thread safety is a key challenge in multi-threaded programming. It was not a concern of most application programmers but since the late 1990s has become a commonplace issue. In a multi-threaded program, several threads execute simultaneously in a shared address space. Every thread has access to virtually all the memory of every other thread. Thus the flow of control and the sequence of accesses to data often have little relation to what would be reasonably expected by looking at the text of the program, violating the principle of least astonishment. Thread safety is a property aimed at minimizing surprising behavior by re-establishing some of the correspondences between the actual flow of control and the text of the program.
• Metaprogramming is the writing of computer programs that write or manipulate other programs (or themselves) as their data, or that do part of the work at compile time that would otherwise be done at runtime. In many cases, this allows programmers to get more done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.
  The language in which the metaprogram is written is called the metalanguage. The language of the programs that are manipulated is called the object language. The ability of a programming language to be its own metalanguage is called reflection or reflexivity.
  Reflection is a valuable language feature to facilitate metaprogramming. Having the programming language itself as a first-class data type (as in Lisp, Forth or Rebol) is also very useful. Generic programming invokes a metaprogramming facility within a language, in those languages supporting it.
  Metaprogramming usually works in one of two ways. The first way is to expose the internals of the run-time engine to the programming code through application programming interfaces (APIs). The second approach is dynamic execution of string expressions that contain programming commands. Thus, "programs can write programs". Although both approaches can be used in the same language, most languages tend to lean toward one or the other.
• Lambda lifting or closure conversion is the process of eliminating free variables from local function definitions from a computer program. The elimination of free variables allows the compiler to hoist local definitions out of their surrounding contexts into a fixed set of top-level functions with an extra parameter replacing each local variable. By eliminating the need for run-time access-links, this may reduce the run-time cost of handling implicit scope. Many functional programming language implementations use lambda lifting during compilation.
  The term lambda lifting was first introduced by Thomas Johnsson around 1982.

As expressed, it was never my intent to demystify all the trendy concepts in technology and programming world. Thanks to the definite source of information, Wikipedia, for assisting in collating the above information.

Hope you find some of it (if not all) useful.

Thanks Mr. Reader for your time! Comments as always, are cherished and welcomed!

Let’s Zune

As a professional developer (don’t care if you disagree) one thing that has always stayed on my priority list is UX (User eXperience). UX is what makes an ordinary app stand out in the crowd and boost its adoption rate. There has been a sudden upsurge in the resources that are now being directed towards designing and developing effective UX.

Media players have been there since forever (it almost seems so) and we all have our personal favorites. Our boxes come bundled up with something default which for some cynical reasons never suffices our hunger for the numero uno media experience. And there begins a never ending exploration for the most amazing media player. It’s surprising though, all that a media player (and I am directing my focus on music primarily) is supposed to do is yell out noise (dear music lover, no hard feelings intended), allow repeat, shuffle and essentially play a single song at a time (how many of you play multiple songs in parallel? Try it out, its fun!).

Developers are always criticized for making simple things complex and that’s indeed true. Media players today have a fortune of features, 90% of which are unknown to lay end users while the remaining 10% of the end users are too busy comparing and contrasting these features with a rival player. With smart media devices rolling out, features like synchronization with the devices and amongst devices, cd ripping and burning from within the player have graduated to become the minimal set of features that a media player must expose to be even considered a decent enough option. When it comes to playing my songs I usually limit down to two players (again, a single player doesn’t simply suffice and I know not why), the primary being Windows Media Player 11 and the secondary being WinAmp, the modest media player for the masses. I stumbled upon Zune Software, the premiere media playing application for the PC primarily targeting Microsoft’s Zune player (aka the iPod killer). For more information about Zune MP3 Player visit here.

The Zune software is what startled me and my curiosity grew when I read the tag line of the Zune software home page which declared: browse music, not spreadsheets. I like the concept and went ahead and decided to try it out. I might sound like the Indian TV news media, but it was AWESOME! AWESOME! AWESOME! (the words repeated directly correspond to propose the degree of awesomeness experienced). What follows is a quick overview of what looked to me as a really cool (again, I don’t know what this word means but it sounds geeky, so must over use it) media player and let me remind you, I don’t own a Zune MP3 Player and I don’t intend to rip music or buy music online. So I was totally concentrated on playing (offline) music that occupied very precious bits on my HDD.

The Now Playing view impressed me a lot especially with the innovative UX that it proposed. Have a look at it:

This single view has colossal amount of functionality and the reason why I love it lies in its unobtrusive UX design. To quickly sync you up with my point, notice the red wave at the bottom center of the window; that’s the visualization, very elegantly forming the part of the player experience. That to me was the Aha! moment. Also notice the basic media player controls and the track bar alongside the play list, completely forming the part of the player but elegantly sidelined for the premiere music playing experience. The player background served the album art of most of the songs that were in my music library (a Windows 7 feature). Hope you notice the back arrow on the top left corner of the window that takes you to the wealth of features that the Zune software supports. Very elegant, more so, mashing up with the general Windows 7 UI experience.

Next up was the mini view; I had experiences of the mini view(s) of many other media players but this looked cooler (yes, I am sounding biased, but you have to try it out yourself to believe me).

There were two other major views that looked astounding to me and if you are like me and keep your music organized and updated, editing even the least used tags of the individual MP3 songs you would love what this software has in store for you.

The collections view looked really simple to me, just displaying enough information as I would need and abstracting away the chores of it. Also, this window links you to all the major functionality of the software. Notice the sign in option that connects you to the world (literally).

 

The final screenshot I wanted to share was that of the edit screen which to say the least, lived up to my expectations:

 

 

This post was never intended to be a product review of Zune software, rather it just wanted to express the really innovative, unobtrusive UI design that seems to be taking the threshold now a days with consumer software.

Leave out your comments (if any) about your experience with the Zune software or any other application that stood out from the rest.

Must admit, the primary reason that made me inclined to try it out was the fact that it was a WPF application (that’s geeky, but then that’s what the developer in me is).

Happy listening!

Installing Life or Uninstalling it?

“But now I have come to believe that the whole world is an enigma, a harmless enigma that is made terrible by our own mad attempt to interpret it as though it had an underlying truth”.

It’s astonishing to discover how many of us are existing without doing the most imperative thing in our life – living! Bizarre, but true, don’t know if anyone of you have observed it, but we (most of us, if not all) suddenly have become enclosed and to some extent aggrieved by the toxic environment encompassing us. And before you start dwelling into the Go Green initiatives, I must declare, this is not about carbon footprint, greenhouse gases or for that matter, earth hour! We are no longer happy (attempts to inherit virtual happiness have failed time and again).

The global economic downturn certainly triggered and aggravated it, but to solely blame it and move on would be an under-observation, indisputably leading to a lethal mistake. A quick glance down memory lane would bring back what now has become the epitome of happiness. School and/or college days, once sloppily spent, have now become desperately desired. Most of us would agree, we all were passionate about our to-be jobs. Why are we then loosing what’s called life – the intrinsically simple phenomenon of enjoying atomic moments sans dependencies?

At the time of inception, happiness, in general was supposed to encompass monetary capacity in general and fulfillment of passion, in particular. Most, if not all of us, have reached a point whereby the monetary fulfillment is somewhat achieved (before you start shouting no ways, ask yourself how much was the first paycheck that you got and how satisfied you were with that and what do you draw today), if not surpassed. What went missing was that flare, that passion which in the first place drew us to what we are into today.

For you Mr. Reader who is still figuring out what this post is all about, let me decompile the above LIL (Life Intermediate Language) code for you. It’s about our (you are allowed to exclude yourself if you so consider) inadequacy to achieve something simple, something atomic – a sensation called happiness! Every other disremembered friend I encounter nowadays seems to have a problem (the dictionary meaning of which is a state of difficulty that needs to be resolved). And regardless of the gravity of his problem, he simply wishes to resolve it! The keyword here is wish (the dictionary defines it as an expression of some desire or inclination), and also consider that one is wishing for the problem to be resolved and not making earnest attempts to do the same. My intent here is to express the undeclared, catastrophic phenomenon that is taking away life as it exists in the purest acceptable form, from most of us.

What follows might be considered a litmus check that attempts to compute whether you are missing life or living it.

If you don’t find yourself reacting yes to most of the points below, then must say

“Houston! We have a problem!”

1. Do you like your company? (Intellisense suggests like as find enjoyable or agreeable)
2. Do you like to work with your immediate superior?
3. Do you like the people adjacent to you?
4. Do you like your day-to-day work?
5. Do you have time for yourself at the end of the day?
6. Do you spend adequate time with your family?
7. Do you have a private domain to cater to? (no Intellisense for this)
8. Do you think your current professional step would lead you to your esteemed destination?
9. Do you consider yourself to be adequately skilled and improving on a routine basis towards your desired level of expertise?
10. Do you believe in yourself and your aptitude to change the tide in your favor?

Shout out your Yes scores in the comments section, would be prodigious to know!

The programmer in me couldn’t resist myself from injecting some code (dependency injection?) into this post, so here we go.

The LINQ query for the above resulting questions could look something like this:

var query = from Moments in Life

where LifeTime != Timespan.Future

select Moments

order by gravity descending; //vital criteria appears first

query, in this case would be an IOrderedQueryable<Life> and not an IQueryable<Life> (I am just venturing into LINQ, so do bring out the compilation errors and/or warnings in the code above).

Happy living and for that, Happy coding too!

Awaiting .NET 4

The .NET Framework version 4.0 is slated for release in April 2010 and everyone seems to be excited about it (everyone by definition includes everyone, so me too). Being the next big release of the framework, there exists number of enhancements and fusion of several new ways of writing old and new smart applications.
I sat down searching for what’s in it for me, the conventional (it’s the most reputable word I could afford for myself, corollary to calling bugs as exceptions) .NET developer for whom writing .NET code is not only about developing cool new smart applications (hardly get to do it thanks to the huge number of legacy and combo apps we need to upgrade day-in day-out) but also write that enlightening code quickly and smartly.
I have made an honest (as if honesty still exists?) attempt to compile what I felt was just so super cool changes to the framework or language in general. Let me #warn you not to expect the entire v4 enhancements from the lines that follow. That won’t ever happen (if I could do that MSDN would be hosted at my local desktop, right?).

1. StringBuilder.Clear(): I was surprised to see this as an addition to the v4 version, as all this time I had expected this member function to be omnipresent in the StringBuilder class (going by the superior and smart design of the .NET framework). Just recently while using it for dynamic html generation (I was using VB9 and still didn’t use VB XML Literals for some bizarre reason, which is indeed classified), I found the absence of this method. The workaround was setting the Length property to 0 which would then clear the contents of the StringBuilder object.
2. String.IsNullOrWhiteSpace(): As is eminent from the name of the method, it checks not only the Null or Empty content of the string object but also helps avoid the use of the Trim() method to make certain we don’t end up with a string of precious whitespaces. An authentic admittance though, I already had added my own extension method in my v3.5 extension methods repository that did verify the absence of both Null and Whitespaces before performing any further string operations and was aptly named String.HasValue(). I am indeed smart (I always knew this, but formally broadcasting it on this DateTime.Now).
3. ServiceProcessInstaller.DelayedAutoStart: While developing Smart Client applications it is a very common requirement to register the application to launch on Windows startup. However, as is eminent, too many applications loading on startup will upsurge the boot time significantly deteriorating the end user experience. This feature comes to the rescue by delaying the start of the application until all other auto-start services have already started.
4. SMTP Client enhancements: Some of the enhancements include enabling SSL mode in application configuration files, specifying heading encoding and most importantly, multiple replying to addresses through MailMessage.ReplyToList().
5. Guid.TryParse(): The TryParse method has now been added to the Guid, Version and Enum types and behaves exactly as its counterparts in other types.
6. 64Bit enhancements: Recognising the mainstream adoption of 64 bit systems the Environment class has been decorated with: Environment.Is64BitProcess and Environment.Is64BitOperatingSystem.
7. IEnumerable<T> everywhere: New overloads of String.Concat() and String.Join() now support IEnumerable elements so that you don’t have to convert them to strings prior to performing Join or Concat operations on them. Also enhanced are several System.IO members like the new File.ReadLines() which returns an IEnumerable<String> rather than a string array. This in turn gives superior performance benefits as its always (read mostly) desirable to read a file one line at time rather than loading the entire content in memory as in File.ReadAllLines().
8. Corrupted State Exceptions: How many times have I written the following?
try{
// Something that should fail, or else why did i incur this try cost, right?
}
catch(Exception ex)
{
// Never do anything here. Let them come back to me for fixes (guarantees job security)
}
In .NET 4.0, corrupted state exceptions will never be caught even if you specify a try… catch block. Even though this is a huge obstacle (a setback or even a crisis) on my attempts towards my job security, yet I welcome it as it encourages writing more stable (in theory) code. Before you start depreciating your intentions to upgrade to .NET 4 for this particular reason, there is a switch that allows you to get the old behavior back by setting the following attribute LegacyCorruptedStateExceptionsPolicy=true in the config file.
This behavior can also be enabled on individual methods with the following attribute:
[HandleProcessCorruptedStateExceptions]
9. System.Data.OracleClient: Before you plunge into thinking why MS shelled it’s resources to enhance OracleClient, instead of their own franchise SQL Server, there is a surprise awaiting you. OracleClient is available in .NET 4 but marked as deprecated. Don’t believe me? No need to, just help yourself by visiting http://blogs.msdn.com/adonet/archive/2009/06/15/system-data-oracleclient-update.aspx .
10. VB Auto Implemented Properties and C# Named and Optional Parameters: These are some of the language specific enhancements essentially following Microsoft’s strategy of co-evolving the two languages.
VB now has auto implemented properties thereby reducing the amount of code generated significantly (I hated VB Dev Center for not introducing it in VB9).
C# developers now stand equal by having named and optional parameters (which to me should have been there at least since v2 of the language).  

The list above was never meant to be exhaustive, it does not even attempt to touch the Parallel computing extensions and dynamic (or functional) enhancements to the framework, but it surely addresses most of us, the conventional .NET developers, writing managed code that manages our company, our clients and primarily us!

Happy Coding!

Truth be told

The IT industry in particular has been guilty of over using (read misusing) acronyms and phrases, the real meaning of which is not known to many, in and outside the industry. The following is an honest attempt for people at large to get to know or revive their knowledge about few such phrases.

Certain terms or phrases used are developer centric but I still believe you would have over heard it while walking past a cluster of developers talking to themselves. The list was never meant to be exhaustive, so inject your own and help educate the people at large (the good people who aren’t part of this typical industry).

• Alpha – a synonym often used in place of the disclaimer clause in relation to software
  
  
• Beta – the deliberate act of making people dependant on software that you know doesn’t work the way it is supposed to.
  
  
• Unit Testing – It’s taking responsibility for the subsequent ill effects of the code you wrote.
  
  
• Integration Testing – the act of shifting the responsibility above to some other person or module.
  
  
• Dependency Injection – the art of writing code that you know will crash, but making sure you alone can fix it. In current scenario, this is the only way to have  job security in the software development industry.
  
  
• Community Technology Preview (CTP) – the only way whereby a company gets testers for free.
  
  
• Release Candidate (RC) – the difference between a CTP and a working release of software.
  
  
• Project Manager (PM) – A mysterious organism over engrossed in excel whole day long, meetings for whom marks the coolest way to chill out.
  

Post in your comments and assist in carrying this list to the next level (Beta 2 to be specific).

Happy Coding!

The Criminal Coder

Mr. Reader, in case you have read my previous posts (in case, is the key phrase here), you might be by now thinking me to have lost my psyche. How can I, the ubiquitous attorney of coders on this planet (and Mars) call them evil? Well, to clear out doubts, they are criminals when compared to their superiors (read developers).

How can anyone deglamorise the developer by comparing him with a coder? To me coders are beginners, not absolute beginners, but people who know stuffs, but simply skip to do them, the way it is meant to be done, for laziness or for reasons I fail to understand. It’s not the lack of intellectual capacity that causes them to commit mistakes (read crime), its rather their sluggishness, that makes them do what they want to do, even if that brings about compromise in terms of the code they inject to dilute (read pollute) the system.

The following are some snippets from production code(basic changes made to trim the demo) that I have encountered, in this short span of life (read professional life), and when debugging performance problems in applications, stumbled upon them, and literally felt like giving digital life imprisonment to those who had the audacity to commit these bits!

• Object declarations inside loops: For simple objects I sometimes feel it’s unavoidable to declare objects of types inside a loop, but for complex types, it’s simply a crime. The following code was intended to improve the performance of the application by spawning new threads. Don’t find the need to say more, the code is self explanatory (and yes, gives a boost to performance):
  
  
  

  public  void UploadXML()
  {
   DataTable dt = GetDataTableFromXML();
   for(int i=0; i<dt.Rows.Count; i++)
   {
    Thread th = new Thread(…);
           th.Start();
   }
  }

  Guess what will be the first problem that your app may run into? An OutOfMemoryException.
  
  
  
• Unacceptable usage of If construct: The code is overly expressive of my intent.
  
  
  

  for(int i=0; i<1000; i++)
  {
   if(IsPostBack==false)
   {
    //Do something here
   }
  }

  
  
• Overly expressive logic: I didn’t have the courage to congratulate this guy and kept shut even after seeing this. There were 10 checkboxes in the page and all of them had this. All of them!
  
  
  

  //As if Checked return a float
  bool b = (checkBox.Checked==true? true: false);
  

  And I have seen even experienced guys do a
  
  
  

  .ToString()
  

  on a string. What more do you expect from visual studio? Auto-detect these overly expressive conversions? Surely, it would do so, may be in VS 2014!
  
  
  
• Global declarations in methods: Why not lazy declare and initialize at the point of usage? We are not in the C age any more (or are we?).
  
  
  

  public void Foo()
  {
   int a, b, c, d;      
   //50 LOC before using c and d
   c=c+1;
  }
  

  
  
• Avoiding short circuits: Short circuits were provided in the language for some reasons, why not use them to decrease the number of characters typed and let the compiler expand them?
  
  
  

  //Enjoy...
  bool a = false;
  bool b = true;
  
  //do something with b here
  if(a ==false)
  {
   //this is left blank (and yes, intentionally)
  }
  else
  {
   if(b == true)
   {
    //Some code to execute
   }
   else
   {
    //Again left blank (intentionally ofcourse)
   }
  }
  

  Why is the following so uncommon to write amongst few geniuses (strict pun intended)?
  
  
  

  if(a == true && b==true)
  {
   //Some code to execute
  }
  

  
  I know you might be thinking who on earth will follow the above pattern and dilute the code, but I have seen it far too many places to avoid mentioning it. Fact is, some coders simply forget the fact that an if can stay without an else. There are innumerable examples and I will certainly update this post to show some really valid places for short circuits, which were completely skipped (and did i mention, knowingly?).
  
  

The above list can’t ever be exhaustive, since each coder has his own pattern of seeing the code. At times I tend to give them (the coders) some leniency by considering their experience with a particular language, but most times, it’s just unacceptable and unforgiveable.

The following is a beautiful extract about the types of competence (or incompetence) that we encounter:

• Unconscious incompetence: You don’t know what you don’t know.
• Conscious incompetence: You know what you don’t know.
• Conscious competence: You know how to do it, but you have to think your way through it.
• Unconscious competence: You can do it without thinking. You just know what to do.

By the way, the reason I termed the above as crime, was because all those coders had live code at their disposal while adding these bits. They simply ignored the style of existing code used in the application and were arrogant enough to not tilt from their style of coding.

To me, that is simply unacceptable and unforgivable crime!

Hail Visual Studio! Save us from the criminal coders!

The agonizing SME developer

Before you begin to think too much into SME, let me sync you up by expanding it for you to the Small & Medium Enterprise (SME). To me these enterprises are a source of raw mystery. When hiring or making decisions up front they are humble to use the latter portion of the acronym (considering themselves no less to Google or MS), and while sharing rewards and parting with their stuffs, the former part is acknowledged (the financial stability is, as they say, on the rocks, literally and did I mention, always).

An interesting find about the word "agony" is that it not only covers intense physical pain but also the "mental anguish" associated with or without it. Through recursion, I soon found out that anguish leads to extreme anxiety or emotional torment. Emotions, almost always, shell themselves into passions, which by the way, is the root cause of misery of all software developers on planet Earth and Mars (they, the guys at NASA, have been shouting all along that life exists at Mars and if life exists, you bet, software developers exist too). So what has a naïve SME developer got to do with agony? Well, at the lowest permissible degree, they were married, in time and space, forever and ever and ever (infinite loop begins, statement truncated).

The lifecycle of an agonized SME developer is what follows…

the morning
A beautiful day begins with a beautiful morning, and this, surprisingly doesn’t hold good any more for the SME dev. Unlike any other professional, the first thought that crosses his (not intending to be gender biased, it’s just natural, you see, it could have been her as well, instead of his) mind is: what can go wrong today, it’s such a beautiful day? Little does he know, that for no fault of his (yes, almost always, there is no fault of his directly, and I am being subjective here) the day will turn out to be, to say the least, bewildering!

the journey to the castle
Notwithstanding the delight of travelling via public transport (describing it as pathetic would be an understatement, hence skipped), he transcends to the castle a.k.a. office in other professions. The unquestionable devotion (no pun intended) towards his work is physically visible as he takes long strides and enters the castle. Life, society, culture, esteem, pride and many other eligible candidates of personal character stay out as he walks in to the castle.

the starters
The most crucial activity of the day begins, checking personal email account. And to just give an example of the overflowing talent in him, even the strictest of firewalls and blockages are incapable of preventing him from accessing his aspirations. His concealed talent, resembling his meager pay slip, can by no measures be hidden, no matter how much he endeavors.

the dream
Unlike other professionals of his age (and beyond), he doesn’t intend to spend (again, skipping waste to avert understatement) his time, forwarding mails to his friends (remember, the social thing in him just stayed out as he entered the castle?). Rather with translucent aspirations, all he searches for (with a far optimized index then what Google can ever manage) is a call from anyone (being complacent) from his list of dream companies. Aghast!  Unlike Google, which returns a million results for even the most horrendous search terms, he witnesses a no results found (that’s why Google roars about its better, less optimized index).

the call
And before he could balance himself, here comes the call, from no one else, but his PM or TL or MD or CEO (remember its SME, so even CEOs have enough time to get on with individuals) or anyone at a relatively higher position then him. Yes, this is it! Life, if ever existed, will cease to exist. Problems, in case they don’t exist, will be created and accredited to him.

the aftermath
The repercussions of the call, a tiny list of tasks, generally, varied in nature and ranging from simple to super complex tasks, to be, in all magnitudes of time, be completed by the currently running day. And did I mention it’s already lunch time!

the optimizations
Being super talented has its own advantages; it allows you to optimize time, beyond the ordinary, spent in professional activities. And the SME dev is no exception, he quickly walks through the tasks list, completing the tasks ranging from simple to considerably complex in irrelevant time spans. The ultimate desire at any point of the day that keeps him inclined - leaving for home (sweet home) at the right time.

the valor
Quickly sensing that the day isn't as good (sarcasm intended) as it was supposed to be, he aims towards his superior with one of the most irrelevant issues of his life, increment (presuming his steady association with the company, which simply refuses to end).

the crime
Approaching for increment in an SME is in itself an offense, unforgiving and regretful. Irrespective of the person being approached, the debate, most of the time leads to a plethora of branching discussions (healthy ones) about - the ubiquitous recession. Even though he wasn't the offender in bringing the slump to the economy in general, still, as a solemn employee of the company, it is his (and solely his duty) to forget increments, incentives, and any other term that relatively maps to the same meaning. He is a developer, passion feeds him, and code recharges him, why on earth has he the need of a better pay scale? Why do we need money? Mostly for our social activities, and if the very social element is missing, why direct the funds in the wrong place?

the return
With an absolute sense of satisfaction, understanding his very own importance in the company and the role (the most important one) that he plays in the general growth of the company (as alluded by his superior), he returns to his desk, unaffected by the discussions, proceeding to what he was supposed to do, code!
The evening is as stale as the dreams he has, and proving his multitasking abilities, he goes ahead in search of his dreams again (accessing his personal email account, remember?) while coding the most complex tasks, wishing them to auto-complete, be auto-verified and surely get auto-published.

the home coming
It would be audacious to imagine that nothing went wrong while the evening squeezed past. Client feedback (mostly neutral, the positive, if any, never make up to him, an auto-transfer mechanism transfers his credits to his superior's account), bug lists, pending tasks (even after a full dedicated day of work) and an extinguished desire to return home is what awaits.
 The journey to home is as exciting (remember the public transport factor?) as it can be and seldom enough does he get time to re-structure his goals (which by now have been declared static).

The day ends, as any other; battles won (and battles lost), nevertheless the passion, the dream, the very sense of being a developer, remains!

Be an SME developer, its an experience life apart!