Software Development Practiec Analysis (Essay Sample)

Software Development Practice Analysis
Student’s Name
University Affiliation
Date
Software Development Practice Analysis
Introduction
Nowadays, the main business of many organizations is mainly based on software. Software systems, such as telecommunication systems and services, such as financial services all depend on software. Software adds significant value to many products and services allowing for competitive differentiation in the market. (Mùnch, 2012) The importance of software development paradigms such as lean or model-driven software development and future software-based applications impose many challenges and demands on software development. Typically, software-intensive systems are developed with hundreds of people in teams. They perform a multitude or different activities. Systematic cooperation mechanisms are needed so as to create customer value successfully and fulfill project goals under given constraints such as deadlines budget limitations. Descriptions of process, so-called process models are, therefore, a necessary means for coordinating such endeavors. According to Mùnch, Process models can be used to define work products, or support the management of resource requirements. (2012). Software and system development is being increasingly performed in different countries with many client-supplier relationships along the development chain. Outsourcing and nearshoring are aggravating this trend, and global software development is close to becoming the norm.
Software systems have evolved from small and monolithic systems to increasingly large and distributed systems. Accordingly, composition gained greater importance because soon software engineers realized that software development could not be described as complex structures, gotten through careful application of a specific composition mechanisms. (Sacha, 2006). Software structure can be analyzed along two directions: process and product architecture. (De, 2008) From a process point of view, composition has to do with the way software development is structured in terms of components and connections.
History of Software Development
In the late 1970s, Information Technology departments running large mainframes controlled most corporate software development projects. The main frame was the infrastructure for enterprise computing environment. (Hamilton, 1999). COBOL was the language of choice, and any department willing to wait for the average Information Technology development programming backlog of more than eighteen months could have the application they wanted to be developed or modified. By then software was difficult to develop because development was so tightly controlled by a small group of people with the skills required and with access to expensive computers. Much of the perceived unresponsiveness of centralized Information organizations was not due to lack of software development skills but simple due to the software architectures imposed by COBOL and mainframes.
During the early 1980s, inexpensive PCs and the popularity of simpler programming languages led to the start of Information Technology decentralization. Now even small departments with no formal Information Technology staff could afford to acquire a PC, figure out how to configure DOS files and get a member with a technical background to learn programming. All of a sudden, big business had hundreds of “unofficial” Information Technology departments springing up. (Hamilton, 1999). The only resources needed were a PC and plenty of floppy disks for backing up the programs.
In the early 1990s, companies started to worry about centralized systems development again. Microsoft Windows replaced DOS and bought a graphical user interface to stand alone applications, along with the whole new level of programming complexity. (Hamilton, 1999). Business managers realized that stand-alone computer applications might solve the need of one department, but didn’t solve the entire enterprise and information flow problems. At that time, UNIX finally matured to the point that it brought mainframe level reliability to client-server systems. This finally helped connect some of those PC islands of automation but at a fee. MIS directors often found themselves supporting three separate development staff: for mainframe, UNIX, and PCs. Fewer computer users than ever, understood about software development and its accompanying infrastructure. Software development however continued to become very complex after the explosion of the internet in the late 1980s. Software development has always been a very complicated process, and the modification is even harder.
The evolution has been consistently in the direction of increasing flexibility: from static to dynamic and from decentralized software composition. For example at the code level, monolithic program structures have evolved to functional and then object oriented program decompositions. At a more abstract level, software architectures developed from tightly coupled composites. (Hamilton, 1999). In a similar way, software processes changed from fixed and monolithic to agile, interactive and decentralized workflows. (De, 2008).
Software Life Cycle Overview
Many people are unfamiliar with the large-scale software development and view it as one-step process. A typical software life cycle includes a number of well-defined stages. Early software development followed a “waterfall” model. One stage was followed by another sequentially in time. (MuÌ€nch, 2012). At the time, if its development, the waterfall model was a large step forward in software development process and identified critical phases such as requirements engineering, software system design, coding and system testing. As organizations adopted the waterfall model, software development tasks such as requirements engineering, software system design, and coding were each done by a separate groups of people. (Hamilton, 1999). Over time, such practices brought their shortcomings to the waterfall model. In large companies, such a model did not foster communication between groups and in fact often prevented it.
Separate requirements design and coding groups developed, but specialists in each area did not necessarily understand the technologies employed by the other project groups. (Mùnch, 2012). Design Engineers in turn would often be misunderstood requirements and develop system models that did not meet user needs. Developers who did not like the plans handed to them made further modifications during the coding phase. Finally, test would be conducted by the inspection team in software artifacts separately.
Trends in Software Development
Today more and more organizations are making a web browser part of the standard desktop environments. Whether for internal usage only or with access to the entire Internet, it is hard to find a corporate desktop today without some web browser. A webtop is no more than a network computing architecture that allows all the user’s functionality to be delivered via their web browser while today most pure “webtop” environments are deployed in single function. (Hamilton, 1999). This is an evolution versus revolutionary process. Since most corporate desktops already have a web browser today, the IT department can start deploying webtop applications at any time using existing desktop PCs.
Once all the requests required by a particular user are available on webtop, the IT organization can evaluate moving to Network Computer clients and further reduce the desktop administration overhead. Many attempts at deploying client-server solutions, however, failed in part because no central group controlled al the distributed desktops that the “client” part of the application had to be deployed on. The main reason so many CIOs in the late 1990s have looked to solutions based on network architectures is that they allow organizations to combine some of the best mainframe and PC paradigms. (De, 2008). The technologies associated with new computing architectures, such as object-oriented programming and the Internet, however, come at a price for building a winning software development team is now much more difficult as IT staffs must be retrained .
Contemporary Software Development Paradigms
Lean and Agile software development paradigms are some of the most successful software development standards. Both seem very similar in their goal design of focusing on the customers and responding to their needs in a rapid manner. It is not understood clearly what distinguishes the two paradigms, but in order to make the best use of these standards it is important to comprehend their similarities and differences for two main reasons: Research results from principles, processes and practices shared by both models are beneficial to comprehend the importance of both paradigms. This helps in generalization and aggregation of research findings to assist in determining the benefits and limitations of both lean and agile at the same time. The understanding of these differences shows opportunities of how the two paradigms can complement each other. If a principle of lean is not applied in agile, it might be a valuable addition. (Dogru, 2011) This comparison is based on the general description of the paradigms. Plan-driven software development is focused on heavy documentation and the sequential execution of software development activities.
The best known plan-driven development model is the waterfall model introduced by Royce in the 1970s. His intentions were to provide some structure for software development activities. As markets became more dynamic, companies needed to be able to react to changes quickly. However, the waterfall model was built upon the assumption that requirements are relatively stable. In response to the issues related to plan-driven app...