communication principles:
*Listen: Focus on the speaker’s words, ask for clarification if unclear, avoid interruptions and
contentious actions.
*Prepare before you communicate: Understand the problem, research necessary jargon, prepare an
agenda if conducting a meeting.
*Face-to-face communication: Best with additional information like drawings or documents.
*Take notes and document decisions: Assign someone to record important points and decisions.
*Collaboration: Use collective knowledge for describing functions or features, build trust, and create
common goals.
*Stay focused: Keep discussions modular, resolve one topic before moving to the next.
Negotiation: Ensure both parties win, collaborate well, and be ready for compromise.
planning principles :
*Understand the scope of the project: Define a clear destination for the team.
*Involve stakeholders in planning: Stakeholders set priorities and constraints.
*Planning is iterative: Plans should be adjusted as work progresses.
*Estimate based on known information: Reliable estimates depend on clear understanding.
*Consider risk in the plan: Adjust for high-impact, high-probability risks.
*Be realistic: Account for human limitations and inevitable changes.
*Ensure quality: Define methods for maintaining software quality.
modeling principles :
*Primary goal is building software, not creating models: Focus on models that speed up software
delivery.
*Travel light—create only necessary models: Avoid creating excessive models to save time.
*Produce the simplest model: Simple models lead to simpler, more manageable software.
*Build adaptable models: Ensure models can accommodate changes without sacrificing
completeness.
*Adapt models to the system: Tailor modeling techniques to fit specific applications.
*Focus on useful, not perfect, models: Avoid over-perfecting models to maintain agility.
*Get feedback early: Review models promptly to catch and correct issues quickly.
Requirements modeling principles :
*Represent and understand the information domain: Identify and organize data flowing into, out of,
and within the system.
*Define the software functions: Specify the functions that provide benefits and internal support.
*Represent software behavior from external events: Show how external inputs drive the software's
actions.
*Partition models to uncover details hierarchically: Break down complex problems into manageable
subproblems.
*Move from essential information to implementation detail: Start with the user’s perspective and
gradually introduce technical specifics.
design modeling principles :
*Traceability to requirements: Ensure the design model is traceable back to the requirements model.
*Consider system architecture: Start design with architectural considerations before component-
level details.
*Importance of data design: Treat data design as crucial as processing functions for efficient program
flow.
*Careful interface design: Design both internal and external interfaces to facilitate efficient data flow
and integration.
*User interface tuned to end-user needs: Prioritize ease of use in user interface design to improve
user perception.
*Iterative design development: Refine the design iteratively, striving for simplicity with each
iteration.
Testing principle:
* Traceability to Customer Requirements :Tests should directly address customer requirements.
* Early Test Planning :Test planning should start as early as the requirements model is completed.
* Pareto Principle in Testing : Focus on testing the 20% of components that will likely cause 80% of
errors.
*Incremental Testing :Begin testing individual components before progressing to larger system
integration tests.
*Exhaustive Testing is Impossible : Exhaustive testing is impossible; aim for adequate coverage
instead.
Deployment principle :
* Manage Customer Expectations : Clearly communicate what can be realistically delivered to avoid
disappointment.
* Assemble and Test Complete Delivery Package : Include all software, data, and documents for
thorough testing across various configurations.
*Establish Support Regime :Plan for customer support and maintain record-keeping for efficient issue
resolution.
*Provide Instructional Materials : Deliver training aids, troubleshooting guides, and updates on
software changes.
*Fix Bugs Before Delivery :Focus on delivering high-quality, bug-free software, even if it means a
slight delay.