Think with Enlab

Diving deep into the ocean of technology

Stay Connected. No spam!

Effective Techniques for a Software Engineer

Introduction

Software development methodologies were introduced and practiced in every project using Waterfall which is the oldest methodology, to Agile which is concerned as a state-of-the-art one. 

Despite the difference in the methodology, the development activities remain: analyzing requirements, designing, coding, testing, and deploying. With more than 20 years of working in the IT industry, I strongly believe that no matter what methodology applied, all of these activities must be done either in a short period of 1-4 weeks or the whole project duration. 

But how to do it efficiently? In this article, I would like to share with you some techniques and best practices to help you be more effective.

Requirement analysis

A software requirement can be a functional or non-functional requirement that needs to be implemented in a software system. 

Functional means providing a particular service to the user. To develop software functionalities, the very first step is to clarify software requirements. Sometimes, you are provided with business requirements instead of software requirements. In this case, follow the requirement elicitation process to define software requirements. Then, start defining requirement breakdown structure to have a whole picture of functionalities you need to implement.

To define the requirement breakdown structure, follow these steps:

  • Step 1: Define software requirements.
  • Step 2: Break down requirements.
  • Step 3: Break down tasks.

See the techniques in analyzing software requirements to learn more about this.

Implementation approach

Implementation concerns

Firstly, when you join a project, you would properly need to prepare your development environment which includes development, communication, and project management tools.

Selecting the right tools and applying suitable techniques will help you accomplish more by doing less. If you’re a .net web developer, these tools are really necessary:

  • Visual Studio
  • Visual Studio extensions like ReSharper, CodeMaid, OzCode, NCrunch
  • WebStorm
  • Communication and collaboration tools could be Skype, Slack, Trello, Azure Boards.

Secondly, you might have to understand the system architectures, code structures, and design patterns being used to comply when writing your codes.

Next, it’s important to master how to structure your code as classes and methods in a way that is highly readable, maintainable, and reusable. A best practice to apply is using a top-down approach to break down your codes. Ideally, write the code skeleton first instead of all lines of code in a method that does the work. In the skeleton, clearly define steps that need to be followed to complete the work. Each step could be a sub-method that is responsible for doing small work.

Top-down implementation example

Below is an example, given the requirement to book an appointment on your calendar.

First, write the code skeleton that represents the work, it looks something like below

public class CalendarService

{

        public Appointment CreateAppointment(string title, DateTime fromTime, DateTime

 toTime, string location, string description, IList<string> participantEmails)

        {

            // 1. Prepare the appointment to schedule

            Appointment appointment = ComposeAppointment(title, fromTime, toTime, 

location, description, participantEmails);


            // 2. Validate appointment conflicts

            IList<string> conflicts = CheckConflicts(appointment);


            if (conflicts.Any())

                throw new AppointmentConflictException(conflicts);


            // 3. Store the appointment before sending it to participants

            SaveAppointment(appointment);


            InviteParticipants(appointment);


            return appointment;

        }

 }

 

Next, implement necessary sub-methods: Now you know what detailed work should be done, so go ahead generating new sub-methods and implement them one by one.

 

public class CalendarService

{

        public Appointment CreateAppointment(string title, DateTime fromTime, DateTime

 toTime, string location, string description, IList<string> participantEmails)

        {

            // 1. Prepare the appointment to schedule

            Appointment appointment = ComposeAppointment(title, fromTime, toTime, 

location, description, participantEmails);


            // 2. Validate appointment conflicts

            IList<string> conflicts = CheckConflicts(appointment);


            if (conflicts.Any())

                throw new AppointmentConflictException(conflicts);


            // 3. Store the appointment before sending it to participants

            SaveAppointment(appointment);


            InviteParticipants(appointment);


            return appointment;

        }


        private void InviteParticipants(Appointment appointment)

        {

            throw new NotImplementedException();

        }


        private void SaveAppointment(Appointment appointment)

        {

            throw new NotImplementedException();

        }


        private IList<string> CheckConflicts(Appointment appointment)

        {

            throw new NotImplementedException();

        }


        private Appointment ComposeAppointment(string title, DateTime fromTime, 

DateTime toTime, string location, string description, 

IList<string> participantEmails)

        {

            var appointment = new Appointment(title, fromTime, toTime, location, 

description, participantEmails);


            return appointment;

        }

}

 

You should implement and unit test one by one instead of writing codes for all sub-methods and testing all at last. You don’t want to do that because you want to divide and conquer.

Effective manual testing

Software testing is not only about verifying the Application Under Test (AUT) but also finding bugs in all aspects of the application to deliver bug-free software. However, as a software developer, in terms of testing, it should be limited to verifying to ensure your software meets all the requirements.

Test requirement breakdown

Either applying automation testing or manual testing, defining test requirements is the first important step you’re required to do. Make sure that you can detail what to test before testing your software. Here are steps to define test requirements:

  1. Understand product documents or AUT
  2. Break down the application to smallest functionalities (Functional Breakdown Structure - FBS)
  3. For each smallest functionality, list out test requirements for the following types:
  • Functional: At least 1 happy path test requirement
  • Look and Feel: At least 1 test requirement per screen
  • Boundary: Special and important input data that can cause problems to the AUT
  • Negative: Cases to verify the unintended behaviors of the AUT

Test case design

As you got the test requirement, let’s move on to design test cases. Each test requirement can be developed into multiple test cases to verify different aspects of that requirement. Executing test cases, maintaining, and tracing are time-consuming tasks. This is an ongoing process to ensure every delivery is qualified.

Common test suites

To be even more efficient, you should predefine some common test suites that can be reused. Here is an example of a common test suite to verify a secure password:

Verify that:

  • User set passwords are from 8 - 64 characters in length
  • Passwords can contain spaces and truncation is not performed
  • Unicode characters are permitted in passwords
  • Users can change their password
  • Password change functionality requires the user's current and new password
  • A password strength meter is provided to help users set a stronger password
  • "Paste" functionality, browser password helpers, and external password managers are permitted
  • Password is one-way salted and hashed
  • The reset password link has a reasonable (maximum 24 hours) lifetime and can be used only once.

Learn more software manual testing techniques to hone your skills whenever you have a chance.

Growth mindset

Mindset is something that mostly affects your decision making when facing challenges. When facing failure, you might think “oh, it is the limit of my abilities” or you might also think “wow, it is an opportunity to grow”. Either it is a fixed or growth mindset, you have a choice.

As software engineers, we solve problems all the time and very often we learn from our mistakes. That’s why a growth mindset is an essential part of software engineers to take the most advantage of their on-the-job learning. 

The market is driven by growth and it becomes more and more competitive day by day. To survive and succeed, especially in this Fourth Industrial Revolution, a growth mindset is the necessary condition. In other words, more than a positive mindset, a firm belief in your ability to learn and grow in any circumstances is important. With a growth mindset, you will go above and beyond your potential. It’s all about raising your expectation for achievements and knowing that you can overcome any challenges when you have the right education, proper practices, and put enough effort into them.

“In a growth mindset, challenges are exciting rather than threatening. So rather than thinking, oh, I'm going to reveal my weaknesses, you say, wow, here's a chance to grow.” - Carol Dweck

In fact, no one has a pure growth mindset. We are all in the spectrum of fixed and growth mentalities and we use appropriate amounts of each on a case-by-case basis. People with a growth mindset are more open to failure and feedback. They learn from their setbacks and turn them into advantages in the future. And for them, feedback is constructive. It’s such a privilege to work in an environment where failures are accepted and feedback is provided constantly.

It does take time to build a mindset and it is hard to change. You need your grit to develop the right mindset. If you are finding your ways, these developers’ mindsets might be useful for you.

Final thoughts

Like other jobs, being a software engineer is not easy. It requires you to arm yourself with a set of skills from requirement analysis, implementation to testing, and develop a growth mindset for upcoming challenges.

After nearly 2 decades of climbing my career ladder, I realize that it takes me many skills and a good attitude to be successful. The utmost skill and attitude are learning, accepting failures, and welcoming feedback. Keep learning and keep doing, that’s the growth mindset and with that, you’re always growing.

 

Contact us

Reference

About the author

CTO CEO Enlab Software Vinh Tran Hi, my name's Vinh and I'm the CEO of Enlab Software. I'm passionate about building world-class digital products, helping my team become mature in their careers, and creating an environment where people find purpose and meaning in life.

Up Next

How to Secure Sensitive Data in The Configuration
October 13,2020 by Tan Nguyen
Introduction On the blog post “How to Configure .Net Core Environments With Practical Examples”, we shared...
How IIS Processes ASP.NET Core HTTP Request
September 30,2020 by Vinh Tran
Have you ever wondered what happens under the hood when you make an API call to...
top-down-approaching-in-programming
September 11,2020 by Vinh Tran
Overview Writing code becomes much easier when requirements are broken down into actionable items with given...
How to Inspect and Improve Memory Usage With dotMemory featured image
September 04,2020 by Vu Dao
In .NET programming, coding with care when using static variables, disposable objects, events, and threads...