Welcome to Linux Forums! With a comprehensive Linux Forum, information on various types of Linux software and many Linux Reviews articles, we have all the knowledge you need a click away, or accessible via our knowledgeable members.
Find the answer to your Linux question:
Site Navigation
Linux Forums
Linux Articles
Product Showcase
Linux Downloads
Linux Hosting
Free Magazines
Job Board
IRC Chat
RSS Feeds
Free Publications

This article deals with the philosophy of the program development and the interesting observation, that user forums are full of feature requests. Some of these requests don't fall into the program functions as the developers see it and thus, the battle between them arises.

Every single line of code out there is made for some special reason. Being code in an email client, a web browser, a file manager or a game does not make a difference. Putting aside the problems of modern programming let's just stop for a minute and say that this special fictitious set of code, like all other lines of code in the open source, is perfectly crafted, bug free command doing exactly what it is supposed to do without any security issues, proprietary licenses or errors. Let's say, that these lines needed ten years of polishing to become the perfect ones, and now they can grow old and live forever. I don't doubt that you believe, such code if existed in this imperfect world, would be written in golden letters, be praised and of course would have never been changed.

Let us wonder for a minute about the characteristics of this code. For sure it should do exactly what it's made for and therefore should not be changed unless the underlying commands that hold the operating system up are changed. So, in the real world, updates are necessary, if for nothing else, to keep in touch with the development of operating systems. That does not however, change the meaning and purpose of the perfect set of code lines, it merely updates and changes it to function on newer basis. It's upgraded and again adapted for the new system to perform faster.

How come then the software changes so much? How come that every type of software is constantly developed, changed, enhanced and upgraded? The title of this article is, as you can imagine, historically looking ata nonsensical question, especially in ever changing IT world. This is because software has a major glitch in its purpose, due to the fact that it is made for the user and every user has his own idea how this code should work. By the user's perspective software is never over developed. It may be developed in the wrong sense for him, but never over-developed. For that reason it could be stated, that if every single user out there would also be a developer and at the same time all these users/developers could have the right to participate in decision-making, then all the software would be bloated from line one to the last one. In those days, when all existing users were also the programmers of the application, that didn't happen. The code was clean, fast and performed just the way it was supposed to perform. The needs of the users are not only different in the ideas of usability, but also in the understanding of the program functioning. A new user does not need to understand how it works, a user needs to accept how to do what he needs to do. To appreciate these statements made, one has to follow the debates in the user forums. There is a constant pressure from the users and this force is equilibrated by the developers. Users demand improved functions, polishing the user interface, logic of operation and even the change of the structure of the system or other the usage of the programs that this line of code depends on. Well who needs such users, right?

From the pragmatic perspective the title of this article is also nonsensical. Most of the statements already made are also somewhere in this paradigm. Program made for any reason has at least one user. More users it has, more wishes the developers will get, but at the same time more wishes that are successfully applied, more likely is to satisfy the greater number of users. Let's look at this from a file management perspective. All functions can be performed using console commands, but somehow nowadays most of us prefer looking at something else then just text. We want GUI. There are numerous possible functions that fall into the file management functionality, but basically denote four sections: primary functions, extended functions, advanced functions and usability enhancements.

Primary functions

create file(s)create one or more text files in the source location
deletedelete one or many files in one or more directories having different properties and permissions
copycopy a file, directory or any combination of those from one location to the other
move move a file, directory or any combination of those from one location to the other
renamein-place rename a file or directory
view filesviewing text formatted, basic graphical or document files
edit text files editing text based graphical or document files
syntax highlightingfor programers of different programming languages
manage directoriesrestructure the directory tree
mount / umountmount and unmount remote locations for usage
searchingfor every possible string or logical expression in as many different aspect as possible
locatesimilar to search
linkinglink one location with another for faster execution
taggingmark a file or directory to be easily and quickly accessible
infodisplay as verbose information about the system or files as possible
sortingsort files and directories by as many attributes as possible
disk / folder / selection space usageoverview of the space occupied or required
directory comparison and filteringcompare two directories on different, remote or local locations
writing to removable mediawrite to different file systems
support / change FS encodingsadapt file system encoding to the one used by the primary system

Extended functions

synchronizingsynchronyze one location to another
multi rename multi-renameing several files, optionally scattered in different locations
multi view / editedit or view multiple files at once
pack / unpack / testsupport for every possible compression
split / combine / testsplit the file in sections of defined sizes and also combine them
merge / convertmerge natively unsplited files and convert them to different types
file comparisoncompare files by contents

Advanced functions

indexing and trackingtrack changes over the time
controlling; creation, deletion, accessbasic security measures
checksum creation-verificationchecking file consistency
virtual foldersfolder for preparation before execution of an action
selection modesgrouping filetypes to logical bundles
search "as you type"fast in-place search
preserve dates on copy, movedo not change file properties upon action
undelete/undo optionsability to threshold executed actions

Usability functions

profilesdifferent user interface views for different operations
bookmarksbookmark frequently accessed locations
tabs / windowscombine and enhance the view of the user interface with tabs
historyremember last used operations
color supportvisualize different types of files
automation / batch / actionsautomate frequently accessed commands
synchronized browsingcompare while browsing
mouse gesturesenhance mouse usability
right-click menuenhance file operations with mouse actions
filtering selectionsfilter the view or selection to perform specific actions

These are the most common functions that can be found in all file managers. More or less all are closely connected to specific file management functions related to any type of files. These, however, are not all functions that are forced by the users. Among others you can find requests for many enhancements that could be branded as by-file management functions. These functions are not primarily associated with the file management, but can in some aspects be folded in this category. All usually still operates with the files, but are correlated with specific documents allowing viewing, editing or executing. These common documents have their own separate applications that usually handle usage and are so common that not many distributions leave them unsupported. Some of them are written in the following table to give an impression.

by-file management functions

browse email folderdirect access to POP accounts
send to emailsending a selection of file by email integrated in the file management
tag and properties editoradvanced editor for metadata of documents
image editorbasic integrated image editor
basic playertakes on basic player functionality for audio and video files
to PDFConvert text to pdf on the fly

This all-in-one paradigm is without question enforced by users from other then unix based, operating systems, where many applications embarked on the route of combining functions. This combining has two aspects, first logical functions and second useful functions. For example, regular expressions are considered extremely important in various applications among advanced users for their logical executions and giving extreme power to the user. Background operations also allow them to place action holders in background and thus releasing program's user interface during the time of prolonged operation. For advanced users functions like this promise working faster. For not so advanced users ability to send a file directly to some email address does exactly the same thing. It enables the ability to work faster. The difference between the two groups is the function orientation and user friendliness. It's the most important aspect for bringing users closer to the products. Most basic users call for user interface upgrades and eye-candy, while more demanding users prefer functionality. In order to attract users, there needs to be a middle road.

To strip down the idea it always comes to the same basis and that is working faster. Undoubtedly there must be functions that are not mentioned in the tables and there is a good reason for this incompleteness. There are more possible functions then possible solutions, since usually different applications take over the specific tasks. That is also the basis of open source development. To answer the question when the piece of software is developed enough, there is a very simple answer. Never! But that does not mean that the code will not be polished. Even though the users demand new and improved functions there is simple solutions. It takes different names like plugins, extensions, user actions, scripts or whatever you want to call them. By breaking down the functions and making them separate of the basic program code, you can satisfy every user out there no matter how advanced his knowledge of the system is. The good thing about that is that you keep the holy idea of breaking functions to smaller parts. Basic functions are done through the application, while other through the plugin extended functionality. This way the users get their combined actions and developers the ease of mind.

If the solution is so simple and we can see it in most common applications, then why is this such a big deal and why do users demand more and more. It comes down to one single problem. Developers are not designing their applications to be expandable. Well, they are, but not from the start. When the application gets their constant user base it's already too late and the code needs to get changed to allow adding third party software and that takes time. Since we started with the file managers, let's end with them. Most of those still developed have widen the aspect of functionalities through some plugin or script system for extending the functionalities, but none of them so far made their whole outline configurable. While advanced users seek plugins that are already introducible, the common users still lack support for user interface lift-ups, mouse enhancements and combining functions.

I once read a reply from a developer to the user about his wish to make user interfaces customizable. His answer was that implementing his idea would mean changing a lot of code and at the same time loosing the sharp and fast interface the file manager developed over the year. Of course at the beginning the programmer made his application sharp and so gaining users that knew how to make it work. When many came they also brought new users, not so function oriented, and the battle began. When you deal with majority, you must keep all the sides open. After all, you rarely see wishes on user forums for console enhancements to get it all curly and colorful, beyond functional basis.

When you start developing a new application, do start with thinking how will you make it extendable in all aspects, especially for the not so technically oriented common users. These are the majority anyway...

Rate This Article: poor excellent
Comments about this article

Comment title: * please do not put your response text here