System Development And Communication Design

Identifying the appropriate architectural style for the system development

• (a)The architectural style based on iterative development

The most appropriate one is the component-based model which integrates iteration while system is being developed. It focuses on decomposition of the design into individual functional components that represent well defined communication interfaces containing methods, events and properties (Tutorial Point, 2017). Choice of this style is based on the following reasons:

-The style enables reusability. It is normally implemented with ‘reuse’ thinking leading the design. This enables the designer to recreate systems easily.

-It also allows replaceability since components which are functionally similar can be substituted.

-Besides, it is never context –specific implying that the components can operate in any environment without much trouble.

-Ultimately, development time is considerably reduced thanks to the reusability feature. This leads to reduced market and development cost.

-Lastly, there is normally a marked improvement in system reliability with this architectural style.

Mostly, the factors which may influence the style chosen above include: the scope of work, purpose of the system, the cost implications,  

The best development life cycle for this case is the prototyping. This type allows large and complex tasks to be broken down into smaller and manageable units. Besides, it provides ease of change during the development process. Several mock ups can be developed before implementation hence boosting the system’s reliability. This type also ensures the user is actively involved during the process; making him feels and claims the ownership. Hence users’ requirements can be met after many iterative modifications (CMS, 2008). Subsequently, the system’s performance can only get better.

Normally, it occurs in four main stages, that is: Initiation, System design, coding and testing, Implementation. In the initiation stage, the investigation is launched with planning taking the lead. The system design enables the user to come up with requirements which must be met in order for system to function appropriately. During coding, the requirements are painstakingly considered. This is where the iterative work begins. Several mock ups are created and passed through tests until the best is realized. However, there is normally a situation where the process can move right from coding to implementation after only one repetitive cycle. Implementation phase ensures the actual operation of the system is realized. Maintenance can be done afterwards to ensure the system always operates as per the operational standards, derived from the system requirements. Hence this style provides an opportunity for the users to experiment with different design fashions before arriving at the perfect one (CMS, 2008).

Choosing an appropriate incremental development cycle for the system

(i) An abstract data type describes a mathematical model used to define and illustrate data structures. In other words, it can be envisaged as a container that holds various objects in a finite fashion together with their associated binary relationship (University of Waterloo, 2012). This allows certain operations among the objects to be possible by simply deriving an algorithm based on the mentioned model.

(ii) Class- According to Yaiser (2011), a class can be defined as a template that contains a set of instructions for the development of a specific object. Therefore, it can only be designed to handle a specific instance. The features of a class include: Methods and attributes. They often facilitate the intended purpose of the class. A typical example can be derived from the given scenario, hence:

Class	Watch (superclass)
	Attributes: color = ‘blue’                   Display= ‘digital’ Methods: get_Time ():double               Show_Date ():string
Inheritance (subclass)	C1: Attributes: Color =’white’ Display =’v5 digital’ Methods: get_Time()	C2: Attributes: Color =’white’ Display =’v2 digital’ Methods: show_date

(iii) A subclass, as defined by Bruce (1998), refers to the class that is generated from the original/parent class. The generated class often inherits some methods and attributes as illustrated above. This enables portions of some codes to be reused in creating new codes by simply making slight modifications in the existing one rather than start from scratch. From above class diagram, C1 and C2 are subclasses derived from a super class called: watch

(b) class diagram with inheritance

Implementing such a given system, that is: solitaire gaming can suitably be done using the model view controller. It can incorporate the required capabilities as follows:

Firstly, the model (representing data needed to facilitate the system built-up) is chosen to be solitaire gaming capabilities; mainly the card selection, color and positioning to exact locations. The user interacts with the system via a graphical user interface (Kobus, 2004). Therefore, the view provides the GUI platform. Normally, the GUI enables the user to track the progress of gaming. Should the user want to make any desired change, he/she can do so by simply modifying the input data. For instance, one may want to change either the level or speed of gaming. Notably, all these actions can only be effected by the controller (Kobus, 2004).

Figure: Block diagram for the Solitaire gaming model-view-controller design

More often, a standalone computer is never connected to the internet. Therefore, its physical security and accessibility are the major issues of concern. To implement a system to address such issues may require implementation of the following strategies according to UPC (2017):

In ensuring physical security:

Creating a use-case diagram for the system users

Providing provisions for booting of the computer from the hard drive only

A password protection system so that should changes be made, let the authorized user be alerted

A locking system to secure the sensitive data to minimize opportunity for encryption

In controlling the accessibility:

There should be provision of security features to very sensitive personal information

Implementing a system on a network

The cisco enterprise architecture can be applied for the purposes of the network implementation (Cisco, 2014). The network is divided into functional blocks without losing the core, distribution and access layers. The access layer normally contains 2 or 3 switches for the purposes of port density (Cisco,2014). Importantly, the core layer provides the highest speed limit interconnectivity between the distribution layers. Additionally, according to Cisco (2014), the servers present are farm and data centre modules.

Normally, before purchase of any of the products and services listed, the following individual set of requirements, on a general case, need to be considered:

(i) Computers

-the operating system typeand capability

-the central processing unit based on the generation for instance, is it a 6^th generation

-The type of graphics it has, for instance does it have integrated graphics incase it is a laptop compueter

-The RAM (Random Access Memory) that is how much is the memory measured in terms of gigabyte.

-The hard drive capabilities in terms of GB.

– Feature of the newtworking hardware, for instance, on which mode does it operate, is it wireless adapter and what version is it

-Software- what kind of software does it have. For example is it office 365 where log in is done with one’s UCSD credentials (ETS, 2017)

(ii) Aroplane

-The flight speed( normally specified in knots)

-The physical size both internally and externally, that is: the interior size based on the number of passengers who can comfortably fit the aeroplane.

-the safety criteria which is critical during emergency situation

-The comfort and wellbeing of the passengers, for instance: by considering the indoor air quality

-The weight of the plane which is based on the materials of the aircraft components and the payload

-The altitude normally maximum height it can climb specified in either meters or feet (NAP.edu, 2017).

(iii) Food processor

-The physical size of the processors

-The number of compartments

-Provision for water supply

-Hygiene and cleaning mechanisms

-Material selection mostly stainless still is the most preferred due to its rust-free property

Communication design and capabilities for system interaction

(iv) Online banking

-Top notch security system that is free from hacking

-The minimum requirements of the personal computer that the customers can use. This is normally given in terms RAM and processor capacities

-Provision of cable and internet connection, that is is the network DSL or ISDN-enabled

(v) Life Insurance

-The health status report done by a qualified physician

-Type of life insurance to be taken

-The amount of coverage

-The age of the person to be insured (Bain, 2007)

(vi) Party planning requirements

-The kind and number of visitors to be accomadated

-The purpose of the party

-Mode of sending the invitations

-The choice of menu and venue

-Contingency plan included where more than option is available to ensure success of the party.

As mentioned earlier, objects are instances of classes. Sometimes, need can arise for them one to access the details of another. This is normally done via messaging. Suppose, object 1 wants to gain access to some details in object 2 for instance, getting some its methods. Notably, concepts of encapsulation and abstraction are often included in object oriented programming. This can present a challenge as encapsulation causes an object to hide the finer details, only basic less sensitive details cane easily be accessed by another object. However, if an object needs to access the methods of another object, for instance, it will require special methods like Getters and Setters to enable access (Python 2 Tutorial, 2017).  

2.4: 3 users, 13 use cases, 1 extend and include for an airline promotion system in Africa

Figure: A use-case diagram for a South African airline Promotion system

References

University of Waterloo. (2012). Abstract Data Types. Available at: https://ece.uwaterloo.ca/~dwharder/aads/Abstract_data_types/

Bruce, K. (1998). Differences between subtypes and subclasses. Available at: https://www.cs.princeton.edu/courses/archive/fall98/cs441/mainus/node12.html

Kobus, J. (2004). Implementing Model/View/Controller. Available at: https://doc.qt.io/archives/qq/qq10-mvc.html

ETS. (2017). Computer Requirements and Recommendations. Available at: https://acms.ucsd.edu/students/resnet/requirements.html

NAP.edu. (2017).Design and Function Requirements for Aircraft Interior Materials. Available at: https://www.nap.edu/read/5073/chapter/4

Severs, L. (2017). Facility Requirements. Available at: https://agr.wa.gov/FoodAnimal/FoodProcessors/facility.aspx#EquipSinks

Pacific Continental. (no year). Hardware and Software Requirements for Online Banking. Available at: https://www.therightbank.com/sites/www.therightbank.com/files/files/Online%20Banking/hardware-and-software-requirements-for-online-banking.pdf

Bain, T. (2007).Life Insurance Medical Requirements. Available at: https://www.quickquote.com/blog/life-insurance-medical-requirements/

Python 2 Tutorial. (2017). Object Oriented Programming. Available at: https://www.python-course.eu/object_oriented_programming.php

UML. (2016).  Use Case Diagrams. Available at: https://www.uml-diagrams.org/use-case-diagrams.html

Tutorial point. (2017). Component-Based Architecture. Available at: https://www.tutorialspoint.com/software_architecture_design/component_based_architecture.htm

CMS. (2008). Selecting a Development Approach. Available at: https://www.cms.gov/research-statistics-data-and-systems/cms-information-technology/xlc/downloads/selectingdevelopmentapproach.pdf

Morse, P.A. (2015). Iterative Model: What Is It And When Should You Use It? Available at: https://airbrake.io/blog/sdlc/iterative-model

Shi, Y. (2015).The 10 Life Cycle Models. Unversity of Winconsin-Plateville. Available at: https://people.uwplatt.edu/~shiy/courses/se273/notes/10-software-life-cycle-models.pdf

Iqbal, H & Apu, K. (2014). MVC Architecture Driven Design and Implementation of java Framework for Developing Desktop application. https://www.sersc.org/journals/IJHIT/vol7_no5_2014/29.pdf