Software Engineering Tips (Part 1)

There is no defined process or methods in Software Engineering that can ensure the
ultimate success of any Software product. While a failed product may have been guided
by the greatest Software Engineering rules, a successful product may not have been
begot through proper engineering process. The right product could be provided when it
is guided through the right path applying the right resources at right time. A good
Software Engineer is the person who can utilize the right ingredients in right time
satisfying the requirements of people and product.

I have been working in a Lead position in Development team for a long time. So I have
taken plenty of interviews. We always hire good programmers. But only being good in
programming does not help to become successful as a Software Engineer. So I share my
experience and thought with my engineers that have helped me in satisfying client
requirements and providing quality work. I would be glad to share few of them here as
well.

Prefer the easiest path to meet the Goal: Remember the objective of work, and
always follow the easiest path to meet the goal. There could be different ways to meet
the destination. Try to follow the simple and right path. Forget about unnecessarily
heavy use of technologies and frameworks. Many times developer wants to use any
specific technology that s/he is interested in. But when we are working for client, it will
be very unfaithful to use something that may not be correct for the client project. We can
give priority to our own preference when we are building our own product. But for client
project, use the best thing that is best for the client.

Design Patterns: Follow industry standards and design patterns in design and
implementation. But never blindly follow known patterns and always use common sense
before using any specific pattern. I had an interesting experience with a boy. He learned
Singleton pattern. Then every time he was asked to write any utility stuff, he always used
singleton forgetting about the context. This reminds me story of a child. Whenever his
teacher asks him to write essay or paragraph he always brings a crocodile in his writing.
Even if teacher asks to write essay on Cow or on Liberation war, somehow a crocodile
appears to eat cow or to play role in Liberation war.

Framework Development: Try to establish generic framework while doing design

and implementation. I always found it heard because of working on different types of
projects utilizing too variant type of technologies. Once we were talking to a potential
client. We presented our expertise to our client. Then he asked to show some of our
work. We denied because of NDA with our clients. But later I realized that if we could
develop any generic and independent framework then it might have been easier to show
some stuff to client.

Identify all solutions: Identify all possible solutions of any specified problem. No
matter if all solutions are not very efficient. I can guarantee that in many cases the best
solution would not be the optimal solution. Especially in legacy systems we cannot
always apply solution that would be best for a new system. We need to understand the
context. Doctor does not apply same dose or same medicine to his/her every patient of
same disease. Good doctor would first check age, and condition of patient and then
prescribe accordingly. Present all solutions to team and to client based on their expertise
identifying pros and cons of each solution. Do the brainstorming and then decide for the
right solution.

Validate Design: Architect system and agree on solution design before

implementation. Do not jump on coding before architecting the solution. And the design
should be validated by team and/or client.

Cost Effective Design: Think and analyze cost effective designs while proposing
solutions.

Regular Status Update: Provide weekly project status to management/client

mentioning current status, future plans and blocking issues.
Coding Convention: Follow the right coding convention. The right coding convention
depends on language, platform, client process, etc. This needs to be discussed among
team.

Code Review: Do aggressive code review. Always ensure that each module of
functionality developed is reviewed by a teammate. If all teammates are novice then
request for external reviewer. But remember that external reviewers may not be able to
confirm that right functionality is implemented in right way. Externals mostly focus on
coding convention and overall design to solution.

Code Documentation: Provide proper documentation and comment in codebase. In

agile process this is very important. When we don’t have enough formal specifications
then this kind of documentation helps a lot. Many developers have very bad habit of not
writing any doc at all.

Continuous Consultation: Always consult with team. Include every possible party in
understanding/analyzing requirements and finding solutions.

Never become Idle: Usually between product releases we enjoy some free time.
Discuss about possibility of improvements, do R&D and study new technologies for
future in free time. Be proactive to get involved in multiple projects to increase your
dependency inside company. Utilize your time. Always do meaningful things. Time is
something that will hurt us acutely in our afterlife.

Unit Testing: Whether we use TDD (Test Driven Development) or not, unit testing
should be mandatory to some extent.

Performance Testing: This is something that must not be avoided.

Be Supportive to Teammates: Software engineers should always be supportive to

their colleagues.

Stand up Meeting: Do regular stand up team meeting. This meeting is not to

understand how an individual is progressing. This is about to understand how team is
progressing. We need to quickly discuss about obstacles and issues in the meeting. For
detail discussion on any problem solving, separate meeting can be arranged with
specific individuals.

Avoid Heavy weight Productivity/Management Tools: Do not get boggled with

heavy weight project management tools. Try to use light weight yet efficient tools.

Code repository: Make sure that latest codebase is always available in code
repository.

Follow Client’s defined Process: Understand and follow the engineering

process/methodology of client. If no process is defined from client then we may present
our own proven process to client.

Incremental and Iterative Software Process: We must follow incremental and

iterative software process. Submit build and prepare documents regularly and be
consistent with project plan. It is very important to remember that when we are
submitting deliverables in any iteration, then we should complete everything regarding
that iteration including design and code documentation, functionality implementation,
testing, and code review.

Do not give stuff for free: While submitting deliverables, make sure the deliverables
satisfies all requirements of client. Sometimes we may give some smart and small
features for free. But we of course should not give full of creativity for free. There must
be some items defined for future release.

Balance exposing Weakness and Expertise: Do not expose weakness to clients

but must not mention anything to client that is not true. We of course cannot accept to
do any work that is beyond our competence level.

No Excuse: Avoid giving excuses to client or management. Show logical reasons at the
very beginning before any possible risk arises.

Study Vendor Manuals: Always study vendor manuals, protocol and regulatory specs
and documents from clients very carefully.
Measure ROI: Do meaningful and fruitful things. Measure the return on investment
and try to be very effective on achieving the benefit.

People and Productivity: Be concerned for the interest of both people and
productivity of company.

Self-Improvement: Continue venture of self-improvement. This is a continuous

process.

Praise coworkers: While working with coworkers internally and in client side, always
try to say good words about coworkers to internal and client management.

No Plagiarism: Strictly avoid plagiarism and follow terms and conditions while using
other’s license or proprietary stuff.

Feasibility Study before selecting any Framework: Always make a feasibility

study before selecting any framework/technology. Do analysis on the long run stability
of the very framework/technology.

Heterogeneity: Psychology of heterogeneity should always be kept in mind during

software development. Software may need to be run on different kinds of devices. We
may need to localize application for different languages. While designing a system, we
should be aware of these.

Keep eyes open: Always keep eyes open and look for new technologies. Analyze and
identify how adapting the new technologies can help our existing and upcoming
projects.

Share Ideas: Do not hesitate to share new ideas with teammates.

Ensure Quality: Do not compromise in providing quality product. While saying no

compromise, it is also to remember that sometimes a product that is fully working but
does not provide best architecture may not be a suitable candidate for re-engineering. It
may severely hurt business if a working product is reengineered only to provide better
system architecture.
Be Proactive: Always be proactive. Keep client running before client drives us.

Documentation: Do documentation. Add diagrams as many as possible in documents.

Seek Help from the Almighty: Seek our Sustainer’s pleasure and help in
approaching problems.