Posted in Developer, Efficiency

An ordinary developer to an efficient developer

A developer is the base key person to bring out a usable product. For a product to be usable, it should meet the quality; it should be efficient enough for the end user. Efficient products can be developed only by the efficient developer. So, being an efficient developer is much more important than being an ordinary developer. Following are the ways, how an ordinary developer can turn extraordinary.

Be a constant learner

Learning is a never-ending process.

There is no person in the world who is updated with all the stuffs. No person can remember all the stuffs learnt. But by constant learning, one updates oneself. New concepts evolve daily; new updates are released periodically; learn to adopt new concepts and try to implement the same.

There is no limit that our mind can say “Stop! There is no more room here”. God created us with almost unlimited storage that has rooms for ephemeral and for permanent. It is up to an individual to fill the storage.

By learning new things, we follow up with the world. In this trendy world, people like new stuffs and use those that are up-to-date. The product that is used by the user needs to have latest trends than being the older one. For instance, when a new technology is invented, it can be implemented in our product only when we are aware of that technology. Awareness can be attained by learning.

A developer needs to research, update oneself with current standards and should have a positive attitude towards learning.

Be a good planner

Failing to plan is planning to failure

Before sitting to develop an application or start our coding, plan. Planning reduces the time consumption. It reduces the hectic re-working process. It gives a clear way ahead. It helps to visualize the end product. It is a good practice to do a rough work before beginning the task.

Once a task is assigned,

  1. Visualize the task and make a note of how it will be at the end of development.
  2. Break the task into small sub-tasks. Break it into granules in such a way it can no more be broken further.
  3. Assign priority for each sub-task.
  4. Create a requirement sheet for each task and make sure that all requirements are met before beginning.
  5. Never hesitate to ask help from people around you to effectively accomplish a task. Remember your limits, you can ask procedure but not expect them to do it for you. Task is assigned to you!

Once everything is done, start with a relaxed mind. Never crowd the mind with external affairs. In the case, when the mind is not relaxed, refresh, divert the attention, take a short break, if possible a short nap would do a lot.

Be DiET focused

As a developer, before starting to develop a code, one should focus on

Device Information

A developer should be aware of the device which is to be coded for. Knowing the details about the device will help in creating an application efficiently that best suits for its conditions. A web application needs to be less weight and responsive to any device. A desktop application must be optimized to consume less memory. It should be targeted based on the operating system. Knowing about the performance will result in an efficient application served for the end user.

End user

Put yourselves in end user’s shoes

Application developed is used by the end user. Hence developer should think in the way a user uses the application. It should be user-friendly, keeping in mind about the appropriate audience. When the application is targeted for the uneducated users, it should help them to learn and operate easily. While it is targeted for the firm, the application should fulfill all the needs of the firm. A developer should understand the need of the user exactly to provide the best outcome.


A code that is developed should be easily readable by other team members. Building complex strategies in a simpler way, using comments wherever applicable are few ways to help others understand. Code should be readable and understandable. This can be achieved when a language’s built-in functions are properly utilized, conditions are exactly used wherever applicable. For instance, excessive usage of ternary operator in the place of if else is most confusing. It would be best if used only for simpler expressions, though it supports nesting, usage in such instances will reduce the readability and leave perplexed. The code should be reusable, easily extensible and organized properly. Even in the absence of a developer, anyone should handle it easily.

Think like tester

Tester always comes with all possible scenarios how a user might use the application. A developer should think end-user centric and should come up with scenarios. Then developing the application to meet all those scenarios will make the application efficient.

Application should be well tested by the developer before being sent to the tester. Delivering a bug-free application will increase the quality. Never think in a way that user might not do in such a way. But assign a probability to every scenario. I have seen web developers relying only on client side validation. Think of someone who uses POST method to push same parameters with same headers, then your application is prone to attack. Both client and server side validations are mandatory in every case.

Although, most of the scenarios will be covered by testers (If a good tester is available) before delivering the application, for an efficient developer, reworking due to a bug is a bad practice. This does not project the quality of developer.

Be an efficient debugger

A developer should be an efficient debugger, should have the quality to identify the root cause of any failures quickly. Debugging can be done in two ways, one by modifying every single level of cause (similar to back tracing – I would say it as brute-forcing) and other is exactly finding out the cause.

It is advised to log events in the application for quick debugging, but remember too much of logging will leave the user with increased disk space and will eventually slow down the application (Yes! Every time log file is opened, written and closed). Have checkpoints and log critical activities.

There are much more ideas for being an efficient developer, but these are some key points. Add your views on being efficient in the comments.


Leave a Reply

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

You are commenting using your 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