Essay:

Essay details:

  • Subject area(s): Engineering
  • Price: Free download
  • Published on: 7th September 2019
  • File format: Text
  • Number of pages: 2

Text preview of this essay:

This page is a preview - download the full version of this essay above.

Dr Graham Roberts

Software Engineering

December 2, 2016

Software Engineering Individual Coursework

Section 1 - Software Engineering

Since the development of the technological era over the past 40 years, the utilization of computers and software programs on both mobile and desktop devices have grown tremendously, both at home and in enterprise. Furthermore, with such a large boom in the use of these products, software has advanced in a number of different ways making it both more expensive to develop and a lot more complex. Utilizing Software Engineering practices allows us to develop these complicated systems in a more streamlined and cost efficient manner. Thus allowing us to keep with the ever evolving technology and even innovate further.

Software Engineering is generally defined as “research, design, develop, and test operating systems-level software, compilers, and network distribution software for medical, industrial, military, communications, aerospace, business, scientific, and general computing applications.”1 Ordinarily, a Software engineer, develops and maintains software programs in various aspects in order to make them more streamlined and hence easier to use. Better quality software enables further development on the program and thus allows easier updates, maintenance and general readability. More often than not, software engineering and development is done in a team to easily divide the different aspects of development and make it easier to utilize as well as reduce the amount of time spent in development.

Section 1.1 - Aims & Objectives

The central objective of Software Engineering is planning, development and maintenance of software programs which may be used by professionals in any field in order to enhance their presence in a technological sense. Furthermore a Software Engineer strives to better their systems and softwares in order to generally make them easier to both update, maintain and understand for future development.

As an aim in the field of Software Engineering, two central factors come into play, time and cost. Both are extremely crucial in a third aspect of importance - Scale. As a software engineer, at the start of the planning phase and towards the end of the development phase, a large focus is placed on developing methods that allow for programs and software to be scaled up for large systems that may be used seamlessly and continually over heavy work load. At the same time, we must try and keep costs low and ensure that the programs are both developed and function within a small time period. Since software has such a large variety of areas for development, all methods have not yet been fully analyzed and so have an extremely large scope for creativity and variation in practice.

Software development in itself was so time consuming and extensive, a large number of issues rose such as with usability, reliability of software and meeting user needs. In order to combat these growing issues, Software Engineering as a field was set up with the prime goal of formulating a systematic approach - “A Process Model”. This was done in order to not only streamline the entire process but also ensure the best use of resources and provide advanced methods to enable unhindered growth.

Section 1.2 - Themes of Interest

Software Engineering in general is divided into a number of sub disciplines which come together to form the different aspects of the development cycle as well as act as tools used to refine the overall process and easily spread out the different tasks required when developing a software. In general the field of Software Engineering can be divided into 15 different sub disciplines:

I have selected 4 of these, which I personally feel are central to the Development cycle and in my opinion the most crucial to make sure that we are as cost effective and efficient throughout our process. The four selected themes are: Requirements Engineering, Software Design, Software Testing and Software Engineering Models.

Section 2 - Requirements Engineering

Seeing as an important issue that arises with the development of any software is meeting user needs, Software Engineering processes usually begin with Requirements Engineering.

Requirements Engineering is generally “concerned with the elicitation, evaluation, specification, analysis and evolution of objectives, functionalities, qualities and constraints to be achieved by a software-intensive system within some organizational or physical environment”2.

Section 2.1 - Description

This component has a central focus on trying to understand user needs and also preempt what changes could occur in terms of User Requirements over the course of a project.   Essentially this stage not only involves an initial talk about the project as a whole, but also consistent communication with the client to understand what exactly they are looking for. This includes their initial idea of how exactly they would like to go about the project and executing their idea, but also all further aspects of the software engineering process. Furthermore, an important aspect/area the software engineer must focus on is trying to understand the end-user needs based on the ideas of the client (who is coming to us to build the app).

Section 2.2 - Aims & Uses

The central Aims that Requirements Engineering has are basically to ensure that the program we develop correctly meets our users needs. It is essential to understand both what exactly the user wants as well as how close our execution of the same is to that initial idea. In effect it not only gives us the initial idea, but also allows us to understand take into account changes over the course of the development process, hence allowing us to meet the user requirements as closely as possible. This initial understanding of user needs also acts as a benchmark to our later development allowing us to try and remain as close to the idea as possible. Furthermore, since this stage is a bridge between our design and implementation, it accounts for the largest part of the development cycle and is hence essential. In general a few central requirements we look at while trying to understand our user’s needs include: Functional Requirements (What our software will do), Quality Requirements (Attributes related to quality), Safety Requirements (Based on software, how to ensure user is free from harm, also includes privacy and confidentiality), Reliability Requirements (Time or scale based requirements for the software), Compliance Requirements (Based on laws of where the software is to be used), Architectural Requirements (The first point of use for the software), Development Requirements (These are non-function based requirements). Lastly an important part of RE is understanding how the software will be used. Use Case modeling is done in order to best understand the different functions of the software and how end-users would interact with it.

Section 3 - Software Engineering Models (UML)

Further down the Software Engineering Cycle, we have modeling which encompass model based development tools which may be used to provide a visual understanding of how our software is to function. UML is the most commonly used and currently standardized means to the visualization of designed softwares.

Section 3.1 - Description

Rather than focussing on low level code, that is manually executed, UML and Model Driven Development (MDD) focus on the development of software systems through the use and transformation of various models to allow the user as well as the developer to visualize and understand how the software is going to work both internally and externally. Models themselves are used to represent either some initial segment of the design process or the entire software itself. Furthermore, they are used to envision how the user (the client as well as the end-user) would interact with the software to try and understand how a developer may better the experience as well as try and bring the final software as close to the requirements as possible, while providing the user with a visual representation of the same along the way.

Section 3.2 - Aims & Uses

Modeling through UML encompasses a large number of different modeling techniques, which are used throughout the development cycle in order to correctly visualize different aspects. The 4 central techniques used are: Entity-Relationship Modeling (ERM), Finite State Machines (FSM), Data Flow Diagrams (DFD)/Class Diagrams and CRC (Communication Diagrams).

As a crucial part of the development process, Modeling comes into play in a number of areas. The first segment of development where modeling would be used is in Feasibility Analysis. Once determined that the software itself is practical and there is a need for the project we are embarking on, we move to Requirements Engineering. As described above, an important part of understanding requirements are Use Cases, these use cases may be modeled to show us how exactly the user is to interact with the software and all of the various different functions they may utilize. Furthermore, Use Cases provide the client with an understanding of how exactly we will be developing the software, allowing them to provide further requirements or making sure our execution is adequate in terms of their needs. As we move forward, the ERM diagrams are used to provide backing to the initial Use Cases, allowing us as developers to understand the relations between a chosen entity and the software in development. Finite States are utilized further down the development process to enable the developer to understand the various scenes/states in which the software will be set depending on the various interactions initiated by the user. Since a software may have a vast number of functions, we model each of these in their own individual FSM. In this segment, state charts are used to integrate these different FSMs without creating too much confusion for the user. Three areas of importance are looked into when analyzing models- Consistency (In UML we compare various models to make sure all data is consistent and each analyzed aspect has the same function when analyzed with various models), Completeness (Ensure all elements of the system are present - no missing behaviors or states) and Validation (Checks to ensure the model correctly follows the requirements).

Section 4 - Software Design

Software Design is another key aspect, however, unlike the previous two, it encompasses a number of different sub-areas which are all essential to making sure the design & software work seamlessly together. Two extremely different areas of work, design and software development must come together to not only meet user requirements, but also maintain a certain sense of aesthetic in order to make the software in development the most visually interesting one for its specific task. Software Design is generally described as “the study of the intersection of human, machine and the various interfaces - physical, sensory, psychological- that connect them.”3. The design of a piece of software provides us with a roadmap to execute better and also further understand how our user is going to interact with he software being provided.

Section 4.1 - Description

Software Design is a central aspect based on a set of principles that lead to the high quality development and deployment of software systems. There are a number of different deign aspects taken into account to ensure that the programmer is able to visualize the software both logically through code as well as aesthetically through various conventional design practices. Software Design is as stated earlier, a link between humans and the software itself. It is a part of the process where ingenuity and creativity are the most crucial aspects in the programmer. It allows the developer to bring together their ideas in terms of the consumer needs, technical considerations and financial aspects of the development cycle and allows them to model their ideas in terms of various different aspects of the software. These different aspects of software where design is pivotal include: Architecture Design, User Interface Design, Interaction Design and Data & Information Design.

Section 4.2 - Aims & Uses

Software Design aims to successfully provide a roadmap as to how to proceed through the entire development process as well as providing granular details regarding more important interior segments which will be implemented in the final output. It allows the developer to understand the program from the inside out and with this knowledge build the software as best possible in order to meet these specifications (taking into account any programming restrictions and also maintaining the overall structure of the software to meet user needs). Architecture Design involves the understanding, function and organization of the internal system and how to structure it to best suit the needs of the software. It is the bridge between the design process and the requirements engineering as it allows us to identify and decide on the main structural components of a system. Interaction Design is essential at the next stage, when trying to bridge the gap between the software and how the user utilizes it. Use Cases allow us to initially visualize and understand how a user would interact with the software, but moving further, wireframes and Usability allows us to understand how close our design is to the requirements we discovered and then accordingly modify and improve on the overall design of the outer interface. Lastly data & information design allows us to analyze the data we will be outputting and allow us to chose the internal data structures which will help us best function the software without too much processing lag.

Some key concepts utilized in all aspects of  Software Design are Abstraction, Modularity, Information Hiding, Complexity and System Structure.

Section 4.3.1 - Abstraction

This concept allows both the user as well as the engineer to focus on the entire project by ignoring excessive details and only focus on the essential properties at each level. This allows us to decide which parts of each level are crucial and set them apart from the rest. Abstraction allows a decomposition of the various components required hence allowing us to individually work on and test the output for each of these individual components.

Section 4.3.2 - Modularity

 This concept allows us to (as mentioned in 4.3.1) split up the system into various levels and work on each module at different times. We design each segment individually and then compile them together into the software as we move along.

Section 4.3.3 - Information Hiding & Complexity

 These concepts account for how each component behaves individually and as a whole. Information hiding allows more complex components to act as “black boxes” to higher levels of code, thus further enabling modularity. At the same time complexity is decided based on a number of factors including depth and time required for processing.

Section 4.3.4 - System Structure

This last concept is required to help provide a mapping for each of the above considerations. Through our design process, it enables us to understand he different modules and gain abstracted information regards how it is we have designed the function of each of these components.

Section 4.3 - Goals & Successes

The Central Goals of research in this field have been to better understand and seamlessly incorporate generally taught design principles to the software programmer in order to allow them to work with the user requirements and more effectively build a program based on not only these needs and a core understanding of software development, but also be able to pre-empt and develop a plan for themselves to visualize and map out their overall output. In effect research in this field has been done to thoroughly incorporate design sensibilities in programming methods. A fundamental textbook wherein such progress was made was in “Bringing design to software - Winograd, T (1996)” where each chapter is authored by a different person who each speaks of one single design/programming based concept and how the interleaving of the two have led to further success on projects and the overall development of the field in practice.

Section 4.4 - Key Researchers, Conferences & Groups

Important Conferences include the “2013 International Conference on Embedded Computer Systems: Architectures, Modeling, and Simulation (SAMOS XIII)”, “2014 IEEE/ACM 36th IEEE International Conference on Software Engineering (ICSE)”, “SDD Deep Dive 2016”. Key Researchers include Dr. David Budgen, Jim Xia and John Robinson. Key Research Groups include: Software Design Group MIT, Autodesk Design Research in Software, Software Architecture Research Group USC and CRC Software Engineering & Design.

Section 4.5 - History & Development

Software Design has consistently been one of the most important aspects of the development cycle, but at the same time one which has not been implemented as widely even today. A large failing in most softwares today arises from the fact that they are not designed at all but merely engineered. A larger emphasis is generally placed on the internal function of the app rather than the external design hindering its overall functionality. However, with such a large boom in design based developments in Hardware, Software today is catching up and a large number of companies deeply incorporate these design sensibilities into their final products to not only bridge the gap between the user and the software but also to integrate it more seamlessly with the hardware it works on.

Section 4.6 - Research Impact

Seeing as Softwares are all around us in pretty much everything we use today, these developments have placed a major emphasis on design and encourage of programmers to focus on design as much as on the engineering of the program. Overall with such a large boom in IoT’s and Artificial Intelligence based softwares today, a better designed software will allow us to work much more seamlessly with all the technology around us and interact with it in a manner that allows us to get the most from it.  

Section 5 - Software Testing

Testing is the final most important aspect of the entire Software Development cycle, it entails the overall functioning of the product and allows the developer to test the outputs agains the requirements set forth by the user further allowing us to ensure that the program both functions as required and also allows the user to interact with it as required. However, testing should not only be looked at as the final part of the process, but rather a link between each step in the development cycle and should be conducted at each of these steps. In essence we should utilize Software Testing to ensure that each module of the program works individually and the program as a whole also functions seamlessly as required by the user and to make sure our software is both free of bugs and also fit to use.

Section 5.1 - Description

Section 5.2 - Aims & Uses

Section 5.3 - Goals & Successes

Section 5.4 - Key Researchers, Conferences & Groups

Section 5.5 - History & Development

Section 5.6 - Research Impact

Section 7 - References

FOOTNOTES

The Bureau of Labor Statistics

Lamsweerde, A. (2009). Requirements engineering : From system goals to UML models to software specifications. Chichester: John Wiley.

Winograd, T. (1996). Bringing design to software. New York, N.Y : Reading, Mass: ACM Press ; Addison- Wesley.

Singh, Y. (2011). Software Testing.

Pressman, R. (2005). Software engineering : A practitioner\'s approach (6th ed.). Boston, Mass. ; London: McGraw-Hill Higher Education.

Vliet, H. (2008). Software engineering : Principles and practice (3rd ed.). Hoboken, NJ: John Wiley & Sons

Bell, D. (2005). Software engineering for students (4th ed.). New York: Addison-Wesley.

Sommerville, I. (2011). Software engineering (9th ed., International ed.). Boston, Mass. ; London: Pearson.

Rosson, M., & Carroll, John M. (2002). Usability engineering : Scenario-based development of human-computer interaction (Morgan Kaufmann series in interactive technologies Y). San Fancisco ; London: Morgan Kaufmann.

Lano, K. (2009). Model-driven software development with UML and Java. Australia ; U.K.: Cengage Learning.

Everett, G., Wiley InterScience, & McLeod, Raymond. (2007). Software testing : Testing across the entire software development life cycle. Piscataway, NJ] : Hoboken, N.J.: IEEE Press ; Wiley-Interscience.

Mili, A., & Tchier, Fairouz, author. (2015). Software testing : Concepts and operations (Quantitative software engineering series Y).

https://en.wikipedia.org/wiki/Software_design#Design_Concepts

http://ecomputernotes.com/software-engineering/what-is-software-engineering-write-basic-objective-and-need-for-software-engineering

https://simple.wikipedia.org/wiki/Software_engineering#cite_note-1

...(download the rest of the essay above)

About this essay:

This essay was submitted to us by a student in order to help you with your studies.

If you use part of this page in your own work, you need to provide a citation, as follows:

Essay Sauce, . Available from:< https://www.essaysauce.com/essays/engineering/2016-12-7-1481142980.php > [Accessed 14.10.19].