Indelicately speaking, self-adaptable software is any software (specialized or otherwise) that has the ability to respond to the needs of the users and doesn’t completely depend on the operating environment and is further proficient in dealing with faults, curtailing the chances of partial or complete failures. At its core it’s flexible. With flexibility, comes complexity. But then, we are software developers, and complexity is as native to us, as pointers to C/C++ (no pun intended).
I am a decently mini-pro type of a PC gamer (I am proud of it, even though its mini) and was trying out FIFA 2010 on my PC with an NVidia GeForce 8400GS graphics card installed onto it. As is true for all the recently launched games, on-board graphics simply doesn’t suffice their needs. They humbly need more powerful GPUs to render the superior graphics intensive characters, surroundings and their interactions. On the beautiful start of a weekend (yes I can still recall, it was a beautiful Saturday morning) my graphics card passed away (pardon me for my emotions, but they are as real as the real data-type).
Utterly shattered, with muted curses to everyone including luck, hardware industry, vendors and my by-now torn off warranty card (it had expired 3months ago); I reverted my display onto the onboard graphics display and began lamenting on the lost opportunities of scoring goals (so what if they were virtual). Being a programmer, and the huge belief (read disbelief) I have with fellow programmers, I decided to run FIFA 2010 without a GPU. To be frank, I was curious to see the error message and the entire experience from the user’s point of view. The introductory video played off, and I was certain of it being a video file with absolutely no requirements of the GPU. The menu came up and I loaded my profile and started a fixture.
“Awesome! EA” is all that I shouted (I actually did). The game ran on software renderer, the graphics were of lower quality, shadows had vanished, the ground looked pale and the players could never look more than androids (read robots). To sum it up, the game was playable and it had adapted to the software renderer seamlessly. A good deal of animation still persisted while really GPU intensive operations were skipped and that didn’t bother me the least. As a user, I was not deprived of my primary objective of playing the game thanks to the self-adaptive graphics system built into the software (i.e. the game). At the core of everything, I sighed
“Why couldn’t all software self-adapt?”
Most of us, most of the times, skip the process of even thinking (forget developing) adaptable systems either because it’s precisely not in the scope of the SRS or maybe it’s not cost effective enough and doesn’t provide the expected ROI. Not only do we expect users to use the software as we intend, we end up limiting their capabilities and implied rights to have self-correcting systems.
To avoid being misinterpreted I don’t intend to make a LOB application go AI and do crazy stuffs. A common scenario of network related dependency can be cited as an example of the ill-intent to not create self-adaptive software. Network turbulence recursively entails us to go berserk almost every day and we wish (at least I wish) the network dependent, and not merely network connected app, could do and let me do something offline.
The issue is not merely of OCA or occasionally connected applications. There could (and would) be plenty of scenarios where we, as developers, limit the users from experiencing the app in a limited way.
Have you recently encountered any of them?
if ( answer == true )