DEV Community: Shodi Farhod

Evolution of Quality Attributes in Agile Software Development

Shodi Farhod — Sat, 13 Apr 2024 04:19:44 +0000

Defining Key Terms

What is Agile Software Development?

Definition: Agile software development is an iterative and incremental approach to software development that emphasizes flexibility, collaboration, and customer satisfaction.

Key Characteristics:

Iterative and Incremental Development
Flexibility and Adaptability
Collaborative Approach
Customer-Centric Focus
Emphasis on Continuous Improvement
Empirical Process Control

What are Quality Attributes?

Definition: Quality attributes, also known as non-functional requirements or quality characteristics, are the characteristics or properties of a software system that describe its overall quality or behavior beyond its functional requirements.

Common Quality Attributes:

Reliability
Performance
Scalability
Maintainability
Usability
Security
Compatibility
Availability
Testability

Different Agile Methodologies

Scrum vs Kanban

Scrum: Scrum is an agile methodology emphasizing teamwork, accountability, and iterative progress towards specific goals. It organizes work into fixed-length sprints where cross-functional teams collaborate to complete tasks from the product backlog. Scrum defines roles such as Product Owner, Scrum Master, and Development Team, along with ceremonies like sprint planning, daily stand-ups, sprint review, and retrospective meetings. This framework fosters transparency, inspection, and adaptation, enabling teams to continuously enhance their processes and deliver value to customers with greater efficiency.

Kanban: Kanban is a visual framework aimed at managing work in progress and streamlining workflow. It prioritizes the reduction of bottlenecks, shortening lead times, and maximizing productivity. Work items are visually represented on a Kanban board, typically organized into columns depicting different stages of the workflow. Kanban stresses the importance of limiting work in progress (WIP) to prevent system overload and maintain a consistent flow of work. Kanban promotes continuous improvement through regular reflection and adaptation.

How do they address quality attributes?

Scrum:
Flexibility: Provides flexibility by allowing teams to adapt quickly to changing requirements through its iterative and incremental approach.
Scalability: Scrum is inherently scalable, as it can be applied at various levels within an organization.
Maintainability: Scrum emphasizes delivering a potentially shippable product increment at the end of each sprint.

Kanban:
Flexibility: Provides flexibility by visualizing the workflow and allowing teams to continuously prioritize and adjust their work based.
Scalability: Kanban is highly scalable, it does not prescribe specific roles or ceremonies.
Maintainability: Kanban promotes a focus on continuous improvement and minimizing work in progress (WIP).

Examples of Agile Methodologies in Use

Many companies use the agile method in their software, some popular examples include the following.

Google
Cisco
Sony
Adobe
Spotify

Evolution of QA in Agile Lifecycle

Early Stages (Inception and Planning)

Flexibility: Strong focus on defining the project vision, goals, and requirements. Encourage flexibility during this stage.

Scalability: May not be prominent in the early stages, especially for smaller projects or teams. Agile methodologies provide frameworks and practices that can scale to larger projects.

Maintainability: Agile teams prioritize practices such as continuous integration, automated testing, and refactoring. Codebase remains manageable and adaptable.

Development and Iterations

Flexibility: Iterative and incremental development allows for regular inspection and adaptation. Enabling teams to respond to changing requirements and customer feedback quickly.

Scalability: As the project progresses, scalability becomes increasingly important, especially for larger teams or projects. Agile frameworks like Scrum provide guidelines for scaling up.

Maintainability: Agile teams prioritize clean code practices, code reviews, and continuous integration.
Codebase remains maintainable and easy to evolve over time.

Testing and Quality Assurance

Flexibility: Emphasize the importance of continuous testing and quality assurance throughout the development lifecycle. Testing is integrated into each iteration, allowing for early detection and resolution of defects.

Scalability: Adopt practices such as test automation, behavior-driven development (BDD), and continuous delivery.
Ensure that testing efforts can keep pace with the evolving product.

Maintainability: Agile teams focus on building a comprehensive suite of automated tests, including unit tests, integration tests, and acceptance tests. To catch regressions and ensure that new features do not introduce defects.

Deployment and Operations

Flexibility: Continuous deployment practices enable teams to release new features and updates to production quickly and safely. Responding to user feedback and market demands.

Scalability: Scalability considerations become more prominent during deployment and operations. Adopt DevOps practices to automate deployment pipelines and scale infrastructure as needed.

Maintainability: Maintaining the product in production requires ongoing attention to ensure reliability, performance, and security.Prioritize monitoring, logging, and continuous improvement to address issues proactively.

Stakeholder Feedback

Let's take a look at trends in stakeholder feedback on the impact of agile practices. These are the most common reviews and feedback given.

Improved Communication and Collaboration:
Highlight the positive impact of agile practices on collaboration and communication within teams.

Increased Flexibility and Adaptability:
Stakeholders appreciate the flexibility and adaptability offered by agile practices, allowing teams to respond quickly to changing requirements and priorities.

Enhanced Focus on Customer Value:
Agile practices emphasize delivering value to customers early and frequently, which stakeholders often perceive as beneficial for ensuring that quality attributes align with customer needs and expectations.

Improved Product Quality and Reliability:
Stakeholders frequently report improvements in product quality and reliability as a result of adopting agile practices.

Challenges with Technical Debt and Maintainability:
Some stakeholders may express concerns about challenges related to technical debt and maintainability, particularly in fast-paced agile environments. Balancing the need for rapid delivery with the long-term maintainability of the codebase can be a recurring challenge.

Need for Continuous Improvement:
While stakeholders generally recognize the benefits of agile practices, they may also emphasize the importance of continuous improvement and refinement. Agile methodologies promote a culture of learning and adaptation.

Conclusion and Recommendations

Recommendations For Using Agile Methodologies

Prioritize Quality Attribute Goals Early:
Prioritize quality attribute goals early in the project lifecycle, aligning them with project objectives and customer needs.

Establish Continuous Feedback Loops:
Agile teams should establish continuous feedback loops with stakeholders and end-users to validate and adjust quality attribute goals throughout the project. Regular review meetings, demos, and retrospectives provide opportunities to gather feedback and make informed decisions.

Embrace Cross-Functional Collaboration:
Agile teams should leverage the diverse skills and perspectives of team members to address quality goals collaboratively, ensuring that all aspects of quality are considered and prioritized.

Integrate Quality Assurance Practices:
Quality assurance practices should be integrated throughout the development lifecycle, with a focus on continuous testing, automation, and validation. Agile teams should adopt techniques such as test-driven development (TDD) and behavior-driven development (BDD) to ensure that quality attributes are validated continuously

Focus on Delivering Value to Customers:
Agile teams should prioritize delivering value to customers early and frequently, ensuring that quality attributes contribute to overall user satisfaction and business value. By soliciting feedback from customers and delivering working software incrementally, teams can validate whether quality attribute goals are being achieved effectively.

Conclusion
In agile software development, quality attributes evolve throughout the project lifecycle in response to changing requirements, feedback, and project constraints. The key findings regarding this evolution include:

Early Emphasis on Flexibility and Adaptability: Agile methodologies prioritize flexibility and adaptability from the inception of a project.
Continuous Improvement of Scalability: Agile practices facilitate the scalability of software projects by providing frameworks and techniques for scaling development efforts.
Ongoing Focus on Maintainability: Maintainability is a continuous concern throughout the agile development process. Agile teams prioritize practices such as continuous integration, automated testing, and refactoring to ensure that the codebase remains manageable and adaptable over time.
Integration of Quality Assurance Throughout the Lifecycle: Agile methodologies integrate quality assurance activities throughout the development lifecycle, emphasizing continuous testing, feedback, and collaboration.

Usability Evaluation of Mobile Application Interfaces in Ride-Hailing Services

Shodi Farhod — Tue, 19 Mar 2024 11:05:54 +0000

CRITERIA DEFINITION

The following tasks will serve as the criteria used to evaluate the usability of mobile applications interfaces with ride hailing features.

Task 1: Setting the Destination
Task 2: Modifying Personal Information
Task 3: Setting Payment Methods
Task 4: Finding Past Ride Records
Task 5: Adjusting Setting Parameters

Which applications will we analyze?

Uber: Provides ride-hailing services, courier services, food delivery, and freight transport.

Lyft: Offers ride-hailing, vehicles for hire, motorized scooters, a bicycle-sharing system, rental cars, and food delivery.

Gojek: Indonesian on-demand multi-service platform and digital payment technology group based in Jakarta.

USABILITY

Task 1: Setting Payment Methods

Uber: Enter the destination in the search bar on the main window.(First Layer)

Lyft: Search for destinations in the main pages search window.(First Layer)

Gojek: Search for destination on main page through tab bar.(First Layer)

Task 2: Modifying Personal Info

Uber: Click account option on the bottom right of the main page.(Second Layer)

Lyft: Open Function Tab, select personal data area, click view profile then choose edit.(Fourth Layer)

Gojek: Click personal avatar on the main page and then click pen to begin editing.(Third Layer)

Task 3: Setting Payment Methods

Uber: Select wallet icon on personal account page.(Second Layer)

Lyft: On main page, open function symbol, then select payment.(Third Layer)

Gojek: From Main Page go to profile page. From there select payment.(Third Layer)

Task 4: Finding Past Ride Records

Uber: Click Activity Icon on the bottom right of the main page.(Second Layer)

Lyft: On main page, open function symbol, then select ride history.(Third Layer)

Gojek: From Main Page select “Orders” Icon to view history.(Second Layer)

Task 5: Adjusting Setting Parameters

Uber: Click personal information on main page, select settings icon.(Third Layer)

Lyft: On main page, open function symbol, then select settings.(Third Layer)

Gojek: From Main Page select Personal Profile and then select manage account. Settings will be available. (Third Layer)

Feedback Analysis

Here are the key takeaways from user feedback on the three different applications.

Uber

Pros:

UI is clean and well designed
Functional Classification is Precise
Provides options for setting destination settings
Popular with young and middle aged people

Cons:

Information of Payment settings is not precise
Automatically install food delivery option which distracts from the main feature of ride hailing.
Navigating pages is not intuitive
The display is more than an average phone’s display range

Lyft

Pros:

Page is simple
Operation is intuitive
Addition of functions toolbar is user friendly
Car calling function is on main page and is easy to access

Cons:

Modifying personal data could be better designed
The settings page was not intuitive
Separate text and image areas were not distinguished enough and caused confusion
Needed to access fourth layer to adjust personal data

Gojek

Pros:

Easily accessible chat function to talk with driver
Provides various features for users
Payment methods are easy to access and easy to use
Provides many methods for payments

Cons:

Provides too much info on main screen, up to six services.
There is too much to explore for new users
Not enough language options, thus making it less accessible
The design felt cluttered and messy

Evaluation and Discussion

Usability Optimization Tips for Ride Hailing Services

Add Signifiers: Have some type of icon of images to help users understand what is being displayed to them.
Separate Features: Different functionalities should be in separate areas. Do not clutter everything onto a single display. For example, how Lyft was able to use a navigation tab.
Main Page-Main Features: Place the most frequently used features on the main page for easy access. The user should be able to immediately select what they want to do.
KEEP IT SIMPLE: LESS IS MORE. Don’t overwhelm users with an over designed UI and many redundant features. The best app should be easily learned and used.

Monolithic vs. Microservices vs. Serverless Architecture

Shodi Farhod — Sat, 02 Mar 2024 09:45:44 +0000

When it comes to architectural styles, developers have no shortage of options. There are numerous viable choices and today we will discuss three popular architectural styles.

What is Monolithic Architecture?

Monolithic means: All components of an application are tightly integrated into a single codebase and deployed and deployed as a single unit. Examples of popular companies that have used this include Netflix, Uber, Spotify.

Remember MONOlithic. "MONO" means one. So you can think of Monolithic architecture as ONE UNIT. In simple terms, monolithic means having your entire project as a single unit.

What are the key characteristics of Monolithic Architecture?

Single Codebase: Everything is coded and developed together
Tight Coupling: Everything is tightly integrated with each other
Centralized Deployment: The entire application is deployed as a single unit

How does Monolithic Architecture Perform?
Let's try and look at some important aspects of performance as it relates to Monolithic Architecture.

Response Times: Monolithic has poor response times, especially for more complex problems. This is because all the code goes through one application. For smaller applications it works better however as your program becomes more complex and larger it can induce latency problems.
Scalability: Monolithic also isn’t able to be scaled well. Because all of the code is closely integrated if one part is changed the rest must also be adjusted to compensate for it. Good to scale vertically, bad to scale horizontally.
Resource Utilization: In a Monolithic structure all components share the same resources, such as CPU and memory. It is difficult to efficiently manage resources because of this. The Monolithic style is not very flexible which further hinders it.

Overall Monolithic Architecture performs better when implementing simple projects or prototypes. However as complexity increases performance decreases.

Developing and Deploying Monolithic Architecture
Another important factor to discuss is how we can develop and deploy a project built using Monolithic Architecture.

Development: Easy to develop. Monolith has simple patterns, like for example MVC structure. There is only a single codebase to keep track of and work with. However this also makes this structure less flexible for developers.
Deployment: Easy and fast to deploy thanks to the entire application working as a single unit. However for bigger applications it may become more complex and time consuming to deploy. Monolithic is best for simpler and more basic applications. Something like prototypes.

We can conclude that Monolithic Architecture is best suited for the development and deployment of simpler projects.

Operational Considerations for Monolithic Architecture
Let's analyze some operational considerations which must be taken into account when using Monolithic Architecture.

Monitoring: Monitoring an application built with Monolithic architecture requires tracking the overall system performance, resource usage and application help. Tools like Datadog, Prometheus or New Relic can be used to keep track of CPU and memory usage, database performance, and response times.
Logging: In Monolithic Architecture centralized logging mechanisms are needed in order to accumulate logs from various parts of the application. Tools like ELK stack or Splunk can be used for this.
Fault Tolerance: In Monolithic Architecture Fault Tolerance involves redundancy. For example having multiple servers, implementing retry mechanisms and handling errors centrally.
Updating/Maintenance: This requires downtime or a maintenance period. Because the app works as a single unit for any part of it to be updated, the entire application must go down for some time.

We should keep this in mind when deciding what type of Architecture Style to use.

Pros and Cons of Monolithic Architecture
Now we will take a look at the advantages and disadvantages of Monolithic Architecture.

Pros: Simplicity: Of the three style, Monolithic is the simplest to comprehend. Performance: Can have lower latency and faster response times for low complexity apps. Ease of Development: Developers have a single unit to develop and maintain. Easier to debug. Ease of Deployment: Entire application is deployed as one unit, making it simpler than Serverless and Microservices
Cons: Scalability: Challenging to scale as the entire app must be changed to handle new additions. Maintainability: As they grow, Monolithic apps become more complex and difficult to manage. Changes in one part of the code impact the entire system. Fault Isolation: A fault in one service of the application can bring down the entire system. Resource Utilization: All components share the same environment and resources.

What is Microservices Architecture?

Microservices means: The application is built as a collection of services. These services are all independently deployed and loosely integrated. Examples of popular companies that implement this include Amazon, eBay, SoundCloud.

Micro SERVICES. Services as in plural. Keep in mind that Microservices revolves around working with multiple services.

What are the key characteristics of Microservices Architecture?

Decomposition: Application broken down to smaller parts
Independence: Each service is developed and deployed on its own
Loose Coupling: Microservices are not closely integrated

How does Microservices Architecture Perform?
Let's try and look at some important aspects of performance as it relates to Mircoservices Architecture.

Response Times: Microservices response time depends on the number of services provided. Microservices can induce additional latency because requests need to be routed through various services.
Scalability: Microservices architecture can be scaled both horizontally and vertically making it the very flexible. Each microservice can be scaled without impacting other parts of the system because services are developed and deployed independently.
Resource Utilization: Because individual sources can be scaled (granular scaling) resources can be efficiently allocated. However, the communication overhead between services and imbalanced workloads can harm its resource utilization. Having services be developed separately allows Microservices to efficiently manage and distribute resources.

Developing and Deploying Microservice Architecture

Development: Microservices are not fast to be developed. It has less code on average than monolithics architecture but its complexity increases. Microservices require multiple services to be developed. This makes it more complex but also makes it more flexible, meaning different resources can be used by different teams and developers.
Deployment: Each service needs to be deployed and managed independently making it more complex. Deploying Microservices means deploying, packaging, and managing multiple services/functions. Because of this microservices deployment is more difficult than monolithic and serverless.

Operational Considerations for Microservices Architecture
Let's analyze some operational considerations which must be taken into account when using Microservices Architecture.

Monitoring: Unlike Monolithic Architecture, in Microservices monitoring means tracking the performance of individual services as well as their interactions. Distributed tracing tools like Jaeger or Zipkin help trace requests as they move through multiple services.
Logging: Each microservice generates its own log. These can then be accumulated using centralized logging solutions. Tools like ELK stack can be used to analyze and collect these logs.
Fault Tolerance: The benefit of Microservices is that it promotes fault isolation. Failures can be contained to their respective services so the rest of the application is unaffected.
Updating/Maintenance: Microservices makes updates and maintenance more manageable by providing independent deployment of services. However it is still important to manage dependencies between services and also ensure compatibility with other parts of the system.

Pros and Cons of Microservices Architecture Architecture

Pros: Scalability: Each component can be scaled independently from the rest of the system. Resource Utilization/Flexibility: Resources can be directed to where they are needed. Fault Isolation: A fault in one service won’t impact the rest of the system. Easy to isolate faults in code Flexibility: Different teams working on different services can use different tools and frameworks for each service.
Cons: Complexity: Have to manage multiple services. Development and deployment is needed for each service. Operational Overhead: Managing a large number of services needs a robust infrastructure. Deployment pipelines, monitoring and logging all add to operational overhead. Coordination: Coordinating changes across multiple services, ensuring backwards compatibility, and managing dependencies is very difficult.

What is Serverless Architecture?

Serverless Architecture means: A cloud provider manages the infrastructure needed to run code. Developers focus entirely on writing and deploying functions. Popular examples include Codepen, Figma, AWS.

It is easy to remember how to distinguish Serverless Architecture. As the name suggests, the developer does not need to concern themselves with servers.

What are the key characteristics of Serverless Architecture?

Event Driven: Functions execute in response to events
No Server Management: Infrastructure is handled by the cloud provider
Pay-Per-Use: Serverless platforms only charge users based on the number of executions.

How does Serverless Architecture Perform?

Response Times: Serverless architecture offers fast response times. In this style it is not needed to manage servers which helps speed up the process. Unlike Monolithic, Serverless is not developed and deployed as a bulk unit so it can support more complex programs.
Scalability: Serverless Architecture offers automatic scaling. The scaling is handled by the cloud platform being used. It is highly scalable but may have limitations when it comes to execution and memory.
Resource Utilization: Resources are provisioned based on need. They are allocated depending on the actual demand and execution requirements of specific functions. Also has pay per use pricing model making it cost efficient.

Developing and Deploying Monolithic Architecture

Development: Serverless architecture has the least code on average of the three however the less the code the greater the complexity. This makes Serverless the most complex of the three. Additionally debugging and testing is more difficult with Serverless Architecture.
Deployment: Can deploy individual functions/services without needing to worry about managing the infrastructure. Cloud providers handle scaling, monitoring and maintenance which simplifies the process.

Operational Considerations for Serverless Architecture

Monitoring: The benefit of Serverless Architecture is that they provide built in monitoring services. Cloud providers like AWS, Google Cloud and Azure provide their own services for monitoring serverless functions.
Logging: Similarly cloud providers also offer their own services for logging serverless functions. Logs are generated automatically by these providers.
Fault Tolerance: Serverless Architecture similar to Microservices inherently provides fault tolerance. This is because it also has its functions executed in separate environments. Cloud providers automatically handle underlying infrastructure and fault recovery.
Updating/Maintenance: Updating and maintaining Serverless Architecture is easier than Monolithic Architecture. Developer’s can update and maintain individual functions without impacting the entire application.

Pros and Cons of Serverless Architecture

Pros: Scalability: Serverless architecture scales automatically based on demand. Makes for efficient resource utilization. Cost: Pay-per-use protocol means you only pay for resources used during execution. Leads to cost savings. Simplicity: Developers can focus on writing code without worrying about managing infrastructure. Fault Tolerance: Serverless architecture means cloud providers handle infrastructure management, including fault tolerance and scaling.
Cons: Less Control: Lose control of server hardware, execution, environments and updates. Vendor-Lock-In: Each provider provides its own unique features so it is difficult to switch between them. Debugging and Testing: Hard to replicate the production environment and run successful tests.

So when should each of these be used?

Monolithic Architecture: This style is best suited for small to medium sized projects. Monolithic is perfect for projects where development time, expertise, and budget are low. This style is good when an application has low complexity and there is not a need for a lot of flexibility and scalability. It is popular when it comes to prototyping.
Microservices Architecture: This style is best suited to large-complex projects. This style is best for when projects have multiple teams, tech stacks, evolving requirements, and where scalability is essential. Microservices are useful when continuous development and deployment is needed. If a team has high expertise then they should consider Microservices.
Serverless Architecture: This style is best suited for event-driven and unpredictable workloads. Such applications can benefit from Serverless Architecture because it scales automatically based on demand. Team expertise should be high if considering Serverless Architecture. Additionally this style is good for stateless applications or functions that can be executed without relying on shared or persistent connections.