Basics & the Algorithmic DocM Model for Software development


Software engineering is the combination of software & engineering. Basics & the Algorithmic DocM Model for Software development.
Software refers to a program or set of programs that when executed provide desired features, functions & performance whereas engineering is all about developing new products using well-defined scientific methods & principles.
So, combining both the aspects, Software engineering may be defined as an engineering branch that is associated with the development of a software product. The outcome of the software development process is an efficient & reliable software product.

Functionality, reliability, efficiency, usability, maintainability, portability, robustness & integrity are some of the main software characteristics. Software is developed with the help of SDLC framework i.e.

Software development lifecycle that has many phases like requirement gathering, feasibility study, system analysis, software design, coding, testing etc. SDLC is a sequence of activities that lead to the production of a software product. A software consumes resources, budget & time.

“Basics & the Algorithmic DocM Model for Software development”
Development of a flexible & efficient software product requires satisfactory software project management. Software development can be divided into two parts – Software creation & Software project management.

Software project management is the art & science of planning & leading software projects. Software product is influenced by four P’s i.e. People, Project, Process & Product. There are many software development lifecycle models like waterfall model, prototype model, spiral model, iterative enhancement model & many more.

Software engineering:

A layered technology Software engineering is an engineering branch that is associated with the development of a software product. There are four layers that act as a base for software engineering. Due to this reason, software engineering is called as a layered technology. All the four layers of software engineering are briefly summarised below-

1. Quality:

Quality refers to the fitness for purpose. It is a subjective aspect. There are many software quality attributes that software must possess. In fact, the bedrock that supports software engineering is quality focus.

2. Process:

Process is one of the four P’s on which software project management focuses. When a software program is executed, it becomes a process.
It is a framework that must be established for effective delivery of software.

3. Methods:

Focuses on HOW to build the software. Each method consists of multiple tasks like requirement analysis, testing, maintenance etc.

4. Tools:

Tools are used to build up the software. Tools provide automated/semi-automated support for process & methods. For instance, CASE(Compute-raided software engineering) tools are used to design & implement applications.
Principles of software engineering Principles are basic ideas or rules that explain or control how something happens or works. Principles in software engineering are necessary for uniformity, discipline & output. Five principles of software engineering are described below-
1. Think through the problem completely before you try to implement a solution: This principle states that firstly, one should understand the problem thoroughly, then only he/she should start implementing the solution because proper understanding of the problem statement & analysation process are necessary to find the appropriate solution.
2. Divide & Conquer: Divide & Conquer approach states that the entire problem must be divided into sub-tasks for proper management. It is also called modularization. This division of the whole work increases the reliability, concurrent execution & maintainability. 
3. Keep it simple: It means that there is no need to make the software process complicated. Developers, project managers & the people who are associated with the software product must keep the software process simple & easy to understand & implement.
4. What you produce, others will consume: It is totally true that software products are made for the users or customers. Developers make them in accordance with the requirements & expectations of the users. Hence, a software must be userfriendly. User/Customer must be able to use the software with ease.
5. Learn especially from your mistakes: All humans make mistakes. There is nothing wrong in doing mistakes but one should learn from his/her mistakes. The same approach follows with regard to software as well. The developers must learn from their mistakes, their ultimate goal must be to produce a quality software product & they should fix the bugs/errors with great attentiveness.
The Algorithmic DocM Model for software development.
The DocM Model stands for Document Maintenance Model. This model refers to a systematic & planned approach for the development of a software. The creation of a detailed document is the most crucial aspect of this model.


There are many steps involved in the DocM model that must be followed sequentially & with great management. The various steps are explained below-
1. COMMUNICATION: The very first phase is communication phase. In this phase, the customer contacts or approaches the service provider or the developer to express his/her desire of software product. The user or customer also tries to negotiate the terms at this step.
2. REQUIREMENT GATHERING: At this step, requirements are gathered from the customer. It focuses on WHAT not HOW. Discussion is carried out between customer & developer. It is an activity that helps to understand what problem has to be solved & what customers expect from the software. The foundation of this phase is effective communication. There are many requirement elicitation methods like interviews, brainstorming sessions, Facilitated application specification technique (FAST) etc. This step involves the practice of collecting the requirements from users, customers & other stakeholders.
3. FEASIBILITY STUDY: In this phase, it is checked that whether the project is feasible (Workable) or not. It concentrates on the operational feasibility, technical feasibility & economic feasibility. At last, a feasibility report is created that specifies whether the project is practically possible or not. This step is just an assessment of the practicality of a proposed system or project.
4. DCT analysis phase: Here, DCT stands for Design, Coding & Testing. This phase is not about the actual implementation, it is about the analysis & forming conclusions. The development team focuses ona.
a. DESIGN: It is all about the modelling techniques like use case approach, Entity relationship diagram, data flow diagram etc. The developer thinks which model must be used to portray the functionalities, behaviour & structure of the software system.
b. CODING: The development team decides which programming language is the most suitable for the proposed system. Actual coding is not started but a general idea is set regarding the programming methodologies. But, pseudo code or rough estimations are possible.
c. TESTING: Testing is the combination of verification & validation. But, at this step actual strict testing is not started. Only the test criteria & test case plan is created. More emphasis is given to the principles & objectives of testing with regard to the software project.
Hence, this DCT phase is only about analysis, planning & estimation. It is not about the actual implementation.
5. Writing Documentation: After the DCT analysis, there comes the role of proper documentation. A detailed document is created by the development team that comprises the following informationa.
a. Software requirements
b. Requirement analysis report
c. Feasibility report
d. Design details
e. Pseudo code
f. Test strategy & test plan
g. Characteristics of the software product
So, this document comprises of all the necessary details about the software product. The creation of this document is a time consuming process because all the details about requirements, design, coding & testing are included in it. The ultimate objective at this step is to generate a formal document that is understandable to users.


Basics & the Algorithmic DocM Model for Software development:  Software is an intangible product. The development of software requires proper documentation, analysis, planning, supervision & management. Software engineering enables us to build complex systems in a timely manner. It is the application of engineering to the development of software in a systematic method.

The power of software engineering must not be underestimated. With the help of software engineering, high quality software can be produced. Moreover, an effective software project management can also help transfer the product from zero to hero.

Hence, this post has explored the software engineering basics & an efficacious methodology/model for the development of robust & reliable software. In this high tech world where user is so fickleminded, building high quality software is not a cakewalk. But, if correct strategies & managerial aspects are followed, then quality software can surely be maintained. Even more fundamentally, it is important to recognize the need of software engineering. The Algorithmic Document Maintenance model described in the end sums this up neatly.

How much did this article help you?


Please enter your comment!
Please enter your name here

This site uses Akismet to reduce spam. Learn how your comment data is processed.