Think with Enlab

Diving deep into the ocean of technology

Stay Connected. No spam!

Effective Techniques for a Software Engineer

 

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 is 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 the requirement breakdown structure to have a whole picture of the 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 for 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, and NCrunch.
  • WebStorm.
  • Communication and collaboration tools could be Skype, Slack, Trello, and 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 the 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

Whether 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 the 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 for 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:

  • Users set passwords are from 8 to 64 characters in length
  • Passwords can contain spaces, and truncation is not performed
  • Unicode's 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”. Whether 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 circumstance 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 and 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 way, 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 and implementation to testing and developing 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

 

References

About the author

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.
Frequently Asked Questions (FAQs)
What are the key stages in the requirement analysis process in software engineering?

The requirement analysis process involves clarifying software requirements, which can be functional or non-functional. It begins with defining the software requirements, followed by breaking down these requirements and tasks to create a clear picture of the functionalities needed. This process ensures a thorough understanding of what the software is expected to do.

What is the importance of selecting the right development tools and techniques in software engineering?

Choosing the right development tools and techniques is crucial for efficiency and productivity. Tools like Visual Studio, ReSharper, and communication platforms like Slack or Trello facilitate smooth development and collaboration. Understanding system architectures and code structures, and applying best practices in code structuring enhance maintainability and readability of the code.

How does the top-down implementation approach benefit software development?

The top-down approach involves writing a code skeleton first, outlining the main steps of the process, and then implementing and unit testing sub-methods one by one. This approach helps in dividing and conquering complex tasks, promotes clarity and organization in code, and aids in easier debugging and testing.

Why is effective manual testing crucial, and what are its main components?

Effective manual testing ensures that the software meets all requirements and is free of bugs. It involves understanding the product or the Application Under Test (AUT), breaking down the application into the smallest functionalities, and designing test cases for different types of requirements, such as functional, boundary, and negative cases. Predefining common test suites for repetitive scenarios can further enhance efficiency.

How does a growth mindset contribute to success in software engineering?

A growth mindset is essential for software engineers as it fosters continuous learning and resilience in the face of challenges. It encourages viewing challenges as opportunities for growth, learning from failures, and being receptive to feedback. Embracing a growth mindset leads to ongoing skill development and adaptability, which are crucial in the dynamic field of software engineering.

Up Next

Big Data Technologies Transforming Software Development
July 05, 2024 by Dat Le
In the rapidly evolving world of software development, Big Data stands out as a transformative force....
June 27, 2024 by Dat Le
In today's rapidly evolving digital landscape, secure coding practices are paramount to safeguarding applications from a...
June 20, 2024 by Dat Le
In the rapidly evolving digital landscape, the role of User Interface (UI) and User Experience (UX)...
Leveraging UX Design Principles in Software Development
June 17, 2024 by Dat Le
In the dynamic world of software development, one element has emerged as crucial to success: User...
Roll to Top

Can we send you our next blog posts? Only the best stuffs.

Subscribe