1. A design should exhibit an architecture that:
(1). Has been created using recognizable architectural styles or patterns,
(2). Is composed of components that exhibit good design characteristics, and
(3). Can be implemented in an evolutionary fashion
For smaller systems, design can sometimes be developed linearly.
A design exhibits an architecture that is clear and concise. This includes using recognizable architectural styles such as communication, deployment, domain, and structure. An architectural pattern is a set of reusable solutions or principles to a commonly occurring problem in a software design or application. The design also exhibits good design characteristics such as the pharmacy not having the ability to access the same information as the doctors. This ensures the design can be implemented in smaller or larger systems because it can be interchangeable between all different possible design patterns. Because of the agile development pattern that our design implements, the design can be developed linearly as well as non-linear.
A design should be modular; that is, the software should be logically partitioned into elements or subsystems.
A modular design is useful because it takes separate components of the design and in the end combines them together. This is crucial in a team environment because different elements can be assigned to different members of a team thus dividing the workload. For example, a member of the team can work on the GUI for the doctors and pharmacists while another member can work on security and testing or documentation. Having a modular design results in a more well-rounded and simple interface that is able to be reused.
A design should contain distinct representations of data, architecture, interfaces, and components.
Our team has excelled in representing the different elements of the design model. We used abstraction to represent our data in the user interface. The raw data is being stored into a database but is translated into an easily viewable screen for the user. The architecture was one of the first elements planned for our software. Our team wanted the overall structure of the software to be very user friendly. The architecture was set for a login screen that would send the user to one screen with minimal windows to manage. Once the architecture was set, the interfaces were designed. Each window was designed with 2 overall goals—ease of use and aesthetically pleasing. We achieved this by clearly defining and labeling the user interface. Lastly, we used abstraction to aid our use of components. We implemented this in the system’s login and search buttons. Those components query the database and take action based on the response. In the graphic interface, the user is not aware of the logic behind each component, keeping the system user friendly.
A design should lead to data structures that are appropriate for the classes to be implemented and are drawn from recognizable data patterns.
Our system’s main data storage is a remote database connected to our java program. Using the database decreases the need for local data structures. The advantages of not having local data structures are faster search and lookup, efficient system, and small memory usage. However, our classes are built to implement the database. Each class connects to the database for a different purpose to create a cohesive user interface.
A design should lead to components that exhibit independent functional characteristics.
A design is one of the most important part of software development process. For example, an engineer designs the structural map of the building before incorporating it into a physical building. Similarly, in software development, design is very important that provides the guideline for the developers to write the code. Here, I am trying to explain how design is important in any field.
Functional independency is possible only when best design approach is applied. The design starts from UML class diagram. As we know that class is anything that represent the enterprise. Modular design increases the efficiency of the development process as it also enforces the divide and conquer method while debugging the errors in programming. Functional independency means attribute independency, and attribute independence allows for the redesign of a module with minimized effects on the rest of the product.
A design should lead to interfaces that reduce the complexity of connections between components and with the external environment.
Interface is very important when it comes to user communication. For example, in our project the pharmacy and the doctor as a user should feel easy while navigating different components of the software. For instance, let’s say the pharmacy wants to look up the patient information to look for the drugs prescribed by the doctor. Here, it will be very inconvenient to look through all the patient. Instead, a search function should be designed to make it convenient for the pharmacy and doctor to look up their patient information. The complexity is drastically reduced while this approach is applied carefully during the design of the user interface.
A design should be derived using a repeatable method that is driven by information obtained during software requirements analysis.
A repeatable method is a set of actions that can be easily duplicated in order to build and couple the designing components for the current development as well as future enhancements of the product. This is essential criteria in designing quality software product since it allows project team to make efficient use of component which impacts the budget over the time.
During the software requirement analysis, our team reached to different medical groups to find out the possible content of E-prescription and finally came up with the designing based on repeated analysis of research data (attributes of E-prescription).
Key steps in developing repeatable method to include:
Understanding the Pharmacy project goal, objectives and stakeholders.
Documenting the current flow of patient prescription process.
Analyzing the significant process gap and possible variations by brainstorming.
A design should be represented using a notation that effectively communicates its meaning.
Our software is designed with notations that is easily understandable, both user interaction wise and programming wise. For the users, in our GUI design, we provided labels for each text area that the users can edit/read so that the user can understand what each text areas represent. For instance, to the left of the text area where the doctor enters the first name of the patient, or where the first name of the patient show up for the pharmacist, we have a label that says “First Name:” which indicates that the text area is there for entering/reading the first name of the patient. Just like this, we have every other text areas for like address, state, zip code, phone and more labeled to the left appropriately (or for some larger sized text areas, to the top). Also, our GUI is designed with headings on each of the windows, “Log In” on our logging in window for example, so that the user clearly understands the purpose of each window. Finally, our menus at the top left corner and buttons located in our GUI are also designed with notations that should sound very familiar to the users. We used very basic words like “Open” and “Save” which are used in most other software around there.
For the developers, we used meaningful notations so that anyone who will be working on this design will have clear understanding of what each of them means. Variables and methods we created for our software’s functionality have appropriate naming so that we can understand what the method or variable is for and their usage. For instance, our text area for the doctors to write in the patient’s first name, or for the pharmacist to read the patient’s first name, is given a name “txtFirst”, which has the abbreviation of the type of variable (text) and a type of information we want (patient’s first name) combined together. Similarly to this, the label variable for the first name is named “lblFirst”.