As information and communication technologists, programming is one of the most basic skills you should know. Programming refers to creating sets of codes that a computer can execute. It involves writing, testing and maintaining code to develop software applications. Moreover, it allows you to communicate with computers and instruct them on how to perform specific application tasks. These application tasks are necessary to develop small-sized applications.
Application tasks refer to specific objectives you must implement within a software application. These are the building blocks that contribute to the app's overall functionality and usefulness. They are defined based on the requirements and specifications provided by the stakeholders or clients.
The purpose of establishing application tasks is to create a clear and structured plan for the development process. By breaking down the app's functionalities into specific tasks, you can better understand the scope of the project. Likewise, you can improve your grasp of the individual components that you will implement.
It is crucial to establish clear and well-defined application tasks. This involves thoroughly clarifying the task with the required personnel. Likewise, it includes identifying the design specifications, programming standards and guidelines. Clear task definition helps developers stay focused, prioritise work and collaborate effectively. It also ensures that the development process is organised and efficient. This leads to the successful implementation of the app with minimal unexpected challenges.
Application tasks are the specific objectives valuable in creating an application. An application is a computer program or a set of programs designed to perform tasks or provide functions for users. It is also known as a software application or app. These applications can be desktop-based, web-based or mobile-based. Applications are vital in this digital age. They enable users to do the following:
- perform tasks efficiently
- automate processes
- access information
- communicate
- interact with digital systems
They enhance productivity and simplify complex tasks. Likewise, they provide value to individuals, businesses, and organisations.
These applications need specific application tasks. Again, an application task is the requirements done during the application development. It defines the functionality, behaviour or action that the application should perform. These application tasks can vary depending on the nature of the app you will develop. However, here are the common examples of application tasks:
This task allows users to create accounts, provide necessary information and securely store user data.
This task ensures the application’s accuracy and integrity. It involves validating and verifying the data against predefined rules or formats to maintain data quality.
This task allows users to handle file upload, storage, retrieval and management within the application.
This task enables users to search for specific information or filter data based on specific criteria.
This task allows users to generate reports, visualise data and provide insights.
This task enables users to communicate between users. It includes messaging features, notifications or email functions.
This task allows users to handle and report errors, exceptions or unexpected events. These may occur during the application's execution for debugging and troubleshooting purposes.
These tasks provide a clear direction and focus for your application. Moreover, these application tasks have specific requirements. Task requirements refer to the specific criteria or conditions you must meet to complete a task successfully. They can vary depending on the nature of the task and the application's context. However, here are some common types of task requirements:
These specify the desired function and behaviour of the task or the system you will develop. They outline what the task should do and the expected outcomes.
These define the technical limits or capabilities you must consider during the task. They may include the following:
- programming languages
- frameworks
- hardware
- software
- compatibility with systems or platforms
- Response times
- Processing speed
- Scalability
- Use of resources
These outline the desired user experience aspects of the task. They cover the following:
- usability
- accessibility
- responsiveness
- navigation
- visual design
- Data protection
- Authentication
- Authorisation
- Encryption
These define the quality standards or validation criteria that you must follow. They include the following:
- Testing methodologies
- Documentation
- Error handling
- Compliance with industry standards or laws
How to establish the application tasks
To establish the application tasks, you must first clarify with the relevant personnel. There are procedures you can follow when clarifying these tasks. These steps can vary depending on the organisation. However, here are the common steps you can follow:
1. Review the task requirements
You must familiarise yourself with the task requirements outlined in the task documentation. Likewise, you must ensure a clear understanding of the goals and objectives of the task. Once you reviewed the task requirements, you must identify the requirements you should clarify before moving on to the second step. This can determine who you should approach to seek that clarification.
2. Identify the required personnel to ask
You must determine the required personnel who can clarify the task requirements, such as the following:
- Project manager: The project manager can provide you with the task's goals and objectives. They can clarify the application's high-level requirements and expectations. Moreover, they can guide you on project timelines, resources and any constraints or limitations.
- Subject matter expert (SME): An SME can provide insights into the functions and behaviour expected from the application. They can help you understand the problem domain and guide you in creating the necessary features.
- Team lead or supervisor: Your team lead or supervisor can clarify the task requirements specific to your project. They can guide you on any unique considerations, technical constraints or coding standards that need to be followed. Likewise, they can advise you on how the task requirements align with the organisation's goals and objectives.
- Quality assurance (QA) team: The QA team can provide input on the application's desired functionality and usability. They can define test cases and validation requirements to meet the criteria. They can also provide insights into areas that may need more attention or consideration.
- Product owner: Product owners define the product vision and prioritise features. They work with stakeholders to gather requirements and translate them into user stories or tasks. Likewise, they collaborate with the development team. This ensures the tasks are well-defined and aligned with the project goals. They provide context and insights into user needs.
- Business analyst: Business analysts focus on analysing business processes and identifying opportunities for improvement. They work with stakeholders to gather detailed requirements and define user scenarios. Likewise, they ensure the tasks align with the business's operational needs and objectives.
3. Prepare clear and specific questions
You must clearly define specific aspects of the task requirements you want to clarify. Write concise and precise questions that address your doubts or uncertainties.
4. Schedule a meeting or discussion
You can schedule a meeting once you have identified the required personnel and prepared the questions. Then, you can request a meeting or discussion through email or internal messaging. Likewise, you must set a mutually convenient time to ensure all parties can focus on the discussion.
5. Communicate and take notes
You must clearly articulate your questions and concerns during the meeting or discussion. Provide context and examples if necessary to ensure a common understanding. Likewise, you must listen to the responses and explanations they provide. You must also document the key points and clarifications discussed during the meeting. Note down any suggestions they provide about your task requirements.
6. Iterate based on the feedback received
You must present the required personnel for initial input. This is a phase where any uncertainties, concerns or suggestions are discussed. The feedback gathered during this stage is carefully considered, and changes are made to the task specifications. This iterative process ensures the task aligns more closely with the desired outcome. It also ensures that potential issues are addressed early. By using feedback at this stage, the process becomes more agile and responsive, resulting in a more effective task.
7. Seek confirmation
You must summarise the discussed clarifications and confirm your understanding with the personnel. You can also ask if your interpretation aligns with their intentions and expectations.
Clarifying tasks ensures a shared understanding of expectations. You can have a clear guide on your task, how you should do it and the expected outcomes. It also reduces the chance of errors or rework and enables you to work more efficiently and effectively. Task clarification is an iterative process that may need ongoing communication and refinement. This continues as the application evolves. You can highlight the value of continuous collaboration and adaptability. This adjusts and refines the application task.
After identifying the task with the relevant personnel, you can start identifying the following:
- design specifications
- programming standards
- programming guidelines
These aspects must be relevant to your task requirements.
Design Specifications
Design specifications are the detailed requirements of the apps' features, functions and limits. These provide a blueprint for the development process. They also guide programmers in creating the desired application.
These specifications can vary according to your task requirements. Here are the common elements included in the design specifications:
User interface (UI) design
This refers to the application's visual appearance, layout and interactions. This may include details about the following:
Functional requirements
These define the specific functions and features the application should have, such as:
- User registration
- Data entry
- Search capabilities
- Data processing
- Data reporting
Data structures and storage
This is the data organisation, storage and retrieval within the application. These may include details about the following:
- databases
- data models
- data relationships
- data validation requirements
Performance considerations
These outline performance requirements, such as:
- Response times
- Processing speed
- Memory usage
- Scalability
These ensure the application performs optimally under different scenarios and user loads.
Error handling and exception handling
These define how the application should handle errors, exceptions and unexpected events. They may include details about error messages, logging methods and recovery procedures.
Security and access control
This ensures the app's security, user data protection and access control methods. These may include the following:
- authentication
- authorisation
- encryption
- secure communication
Testing and quality assurance
These outline the testing and quality assurance procedures. They ensure the application meets the specified standards and functionalities. Likewise, these may include the following:
- test cases
- test scenarios
- acceptance criteria
- platform and technology considerations
Integration and compatibility
These are the choice of programming languages, frameworks and libraries. They also include the platforms you will use in developing the application. These may include compatibility and limits from the target platform. These are any integration requirements with other systems or platforms and compatibility considerations. These include different operating systems, browsers or devices.
Design Specifications
You must refer to the design specifications document available for the application. The design specification document includes the following:
- Textual descriptions
- Diagrams
- Flowcharts
- Wireframes
- Other visual representations
These can effectively communicate the desired design. However, if the design specification document is not available, you can check the following sources:
You can look for project documents from clients or project managers. These documents often include design specifications or references to them.
You can check if there are specific design briefs created for the project. These outline the app's desired design and functionality, including its design specifications.
You can consult experts who have created the app's design mockups. They often contain the app's detailed specifications for the visual and interaction aspects.
You can consult the relevant personnel discussed in the previous subtopic. You can ask them about the app's design specifications.
You can check for any existing design or UX/UI documentation. These provide detailed specifications for the following aspects of the application:
- design elements
- layout
- colour schemes
- typography
- interaction patterns
You can use these practices to know if design specifications are relevant to the task requirements:
- Review the design specifications and compare them with the task requirements. It will ensure they align with the specific functions and features needed for the task.
- Assess the scope and context of the project and the specific task at hand. Design specifications should be relevant to the project goals and the specific task requirements.
- Compare the design specifications with other project documentation. This includes functional requirements or user stories. They will ensure consistency and coherence between different projects.
- Clarify from relevant personnel about the relevance of these design specifications. They can guide you on the applicability of the specifications. They may have specific requirements to be addressed in the design specifications. Clarifying with them can ensure the design specifications meet the expectations and needs.
Programming Standards
Programming standards are conventions and rules followed by the ICT industry when writing code. These standards can include the following:
- naming conventions
- code formatting
- documentation and comments
- error-handling
Naming conventions
These identify how to name variables, functions, classes and other code entities. They ensure clarity and consistency in naming conventions across the codebase. You should remember that the specific naming conventions may vary. This depends on the programming language and the development team. Here are some examples:
- Camel case: It capitalises the first letter of each word except the first, e.g. myVariable or calculateSum().
- Snake case: In snake case, words are separated by underscores, and letters are lowercase, e.g. my_variable, calculate_sum(). Snake case is commonly used in languages like Python.
Code formatting
Code formatting defines the rules for indentation. Likewise, it determines the line spacing, use of whitespace and other formatting conventions. It improves code readability and maintainability. It also helps when many developers are working on the same codebase. Consistent formatting improves code comprehension, reduces errors, aids debugging and facilitates smooth teamwork. It makes the development process more efficient and effective. Here are some examples:
Indentation
It uses spaces or tabs to align code blocks consistently.
In this example, spaces align the code blocks consistently. The code inside the function 'calculate_sum' and the 'if' and 'else' blocks are indented with four spaces. This creates a clear visual separation and hierarchy of the code.
Spacing
It places spaces around operators, after commas, before and after parentheses, etc.
In this example, spaces are placed around the assignment operator (=) and the arithmetic operator (+). They are also added after commas to separate function arguments. The spaces enhance readability and make the code more visually structured and clear.
Line length
It limits the length of lines for better readability, often around 80–120 characters.
In this example, line length is limited to around 80–120 characters by breaking long lines into many lines. It improves readability as the code does not extend beyond a certain width.
Documentation and comments
These are requirements for documenting code. They include the use of comments and documenting functions and classes. Moreover, they can provide data on the code's purpose and usage and generate documentation for future reference. They help you understand and maintain the codebase. Here is an example:
Inline comment
It adds short comments on the same line or preceding the code to clarify intentions or provide context. The '//' is used in languages like C, C++, Java or JavaScript, while '#' is used in Python for inline comments. Here is an example:
In this example, they add inline comments on the same line or preceding the code to clarify or provide context. These comments explain the purpose or intention of the code snippet. These are useful when a specific line of code needs more explanation or when documenting a quick code summary.
Error handling and exception handling
These define practices for handling exceptions, errors and unexpected conditions. Moreover, these include error message formats, logging mechanisms and error-handling techniques. For example, they log relevant information about errors to aid in troubleshooting and debugging.
How to identify programming standards
To identify programming standards, you can use these common sources:
- language documentation
- style guides and coding conventions
- organisation-specific guidelines
You can consult the official programming language document. These resources often include coding standards specific to the language.
Many organisations have style guides or coding conventions. These outline the recommended practices for writing code. Likewise, they cover various aspects like naming conventions, code formatting, code structure and other aspects of writing code. You can check if your organisation has its coding standards.
You can check if there are specific programming standards in your company. These standards may contain coding conventions, style guides or internal documentation. Likewise, these standards are tailored to the organisation's specific needs. They are also tailored to the development practices and industry requirements.
You can follow these practices to know if the programming standards are relevant to the task requirements:
- Understand the requirements of the task you are working on. Identify the app's specific goals, functions, limits and expected outcomes. These will help you check whether the programming standards align with the task requirements.
- Review the programming standards you have identified. Assess its applicability to the task requirements.
- Consider the task's context for any specific limitations. Some programming standards may be more appropriate for large-scale apps. On the other hand, some standards are more suited for smaller projects.
- Consult with project managers or subject matter experts to gather their input and perspective. You can see how the standards align with your task requirements. Their insights can help determine if the standards are relevant and valuable to the task.
Programming Guidelines
Aside from programming standards, there are also programming guidelines that you can follow. Programming guidelines are recommended practices, principles and suggestions followed within the ICT industry. They guide coding styles, naming conventions and other aspects of software development. Likewise, they are more flexible compared to programming standards. You can adopt these guidelines to suit specific tasks.
These guidelines can vary depending on the organisation. However, here are standard guidelines you can follow:
You can use descriptive names for variables that reflect their purpose and functionality. For example, instead of using single-letter variable names like 'x' or 'i', you can opt for more descriptive names like 'counter' or 'studentName'. It ensures uniformity and clarity across codebases, simplifying collaboration among developers. This practice enhances code readability, reducing confusion and errors. Moreover, consistent variable names ease code maintenance and scalability. Thus, they foster an organised and sustainable development process.
You can use this to structure your program into smaller modules that perform specific tasks. These modules can be developed once and then reused across different parts of the application. By designing code with modularity, you enhance readability, maintainability and scalability. Likewise, it simplifies debugging and testing processes.
You can add comments to provide context, explain non-obvious code sections and clarify the code's intent. For example, you can use comments on any code to document the purpose, logic or any other relevant information. These can help future readers to understand the code better.
You can use appropriate error-handling techniques for exceptions and unexpected situations. For example, use a consistent approach for logging errors across the codebase. When writing codes, having a good error-handling approach helps to catch and fix mistakes in the code. This makes the program work better and avoids unexpected crashes.
You can document code to provide an overview of its purpose, functionality and usage. It can help you understand the code better. For example, you can include high-level comments at the beginning of each file to explain its role. Code documentation is vital as it explains how the code works. This helps other programmers understand and use the code correctly, making it easier to collaborate on projects.
You can develop clean, well-organised and maintainable code. It keeps functions concise and focused on a single task. By limiting the length of functions, it is easier to understand, test and maintain. Short functions promote the separation of concerns and reduce complexity. This makes it simpler to grasp the logic and flow of their programs. Moreover, adhering to this guideline lays a foundation for good coding practices.
You must remember that these guidelines offer more room for adaptation. On the other hand, standards are prescriptive and enforce consistency across projects. To identify programming guidelines, you can use these sources:
- Community and industry guidelines: You can participate in programming communities, forums and online discussion platforms. You can gather insights into commonly accepted programming guidelines. Online resources and forums often discuss and share advice on coding guidelines.
- Peer collaboration and code reviews: You can collaborate with other developers within your team or through code review processes. Discuss and exchange ideas about coding practices. Peer code reviews can provide an opportunity to learn from others. Likewise, they can identify potential guidelines the team or organisation can use.
- Industry guidelines: You can stay updated with industry trends, blogs and articles. Industry experts often share their insights on programming guidelines. You can use these emerging guidelines in your coding practices.
To determine if these are relevant to the task requirements, you can follow the same practices in programming standards. However, you must also balance following and adapting these guidelines to meet the task's specific needs. They ensure the codes are consistent while addressing the task requirements. This makes it easier for developers to understand and maintain the application. Likewise, following these standards and guidelines improves the app's quality and strength. Following them helps developers produce more reliable and secure codes.
Watch
You can watch this video to learn more about the programming standards and guidelines:
Quiz
