• Management and organization: Stakeholders in the organization, such as product or project management, often consider new features the most important software engineering assets. Considerations such as “the softwarearchitecture design should be done correctly in the first place so that no problems might ever appear” ignore the fact of continuous change in all but trivial projects. Firstly, software architects do not initially know all requirements—at least not in full detail. Thus, their decisions can only take existing knowledge into account. As soon as the knowledge deepens, previous decisions need to be checked and refined. Secondly, big design up front does not work—which leads to piecemeal growth as the only viable alternative. However, piecemeal growth requires constant QA of all design artifacts and thus also needs architecture refac- toring. A common problem in this context is that architecture refactoring, like testing, can typically prove its value only after project completion. There might not be any immediate return on investment, but experience has shown that neglecting QA is much more expensive than introducing regular quality checks and improvements. Test-driven design (TDD) is a common answer to this prob- lem, because it enables early detection of quality problems. Another known chal- lenge is the inappropriateness of organizations. According to Conway’s law, organization often drives architecture. Hence, bad organization may lead to bad architecture. If the responsibilities are spread inappropriately across organi- zational units, almost all architecture refactoring activities might force the orga- nizational units to cooperate in a tight fashion—which might not be feasible, for instance, when organizational units are geographically distributed or follow dif- ferent goals.
The term Reference Architecture refers to the deﬁnition of an architecture for a particular application domain. An example domain might be satellite ground control systems or telecommunications switch network management. The reference architecture describes the high-level set of elements involved in applica- tions from a particular domain along with their interactions. These elements must intentionally be left at a high level to apply to a large number of systems for that particular domain. Reference architectures are often used to focus on subsystem deﬁnition rather than application process level deﬁnition. Reference architecture deﬁnitions also provide an excellent framework for development of a speciﬁc system in that application domain and can save the software architects a signiﬁcant amount of time rediscovering these elements. In addition, the naming conventions used in the reference architecture provide a common language for architects and application developers to communicate. The func- tional and interface deﬁnitions provided in the reference architecture also provide an opportunity for third-party COTS products to be developed that can be used by software architects for signiﬁcant portions of the ﬁnal system.
The system can be booted without Auspex functionality by specifying the -auspex flag in the boot command. This will cause the system to ignore all Auspex components and run as a simple Solaris 2.6 machine. This may be useful for troubleshooting, and is also required when upgrading the Auspex software.
Agile practices can address EA Challenges. More speciﬁcally the following agile practices are of importance: the ability to deal with changing requirements, reﬂecting on the process and a focus on the essential. An emphasize on these agile practices is very likely to result in less EA challenges perceived in an organization. Interesting is that certain key agile practices such as incremental and iterative development are not signiﬁcant. The conclusion is based on a literature review, qualitative study and expert review. The literature review provided three pieces of information: (1) a decomposition of agile principles in eleven agile practices, (2) fourteen challenges related to EA development and (3) partial evidence that current EA development adheres to waterfall principles and, like software development, might beneﬁt from agile principles. The literature review also revealed that agile practices are already being applied to EA. In these cases the assumption is made that this improves EA development. Validating this assumption is not within the scope of previous research. Based upon the literature a conceptual model was deﬁned reﬂecting a positive relationship between agile practices applied to EA and the EA challenges perceived.
Trying to keep up the appearance of agile, the developers were allowed to func- tion autonomously and write software based on what capabilities they deemed were required at each “Sprint.” Meanwhile, the manager made sure the Earned Value Cost Performance Index (CPI) and Schedule Performance Index (SPI) at the end of each reporting period were always 1, assuming the teams would end up finishing the software on time, would meet the customer requirements, and in the end, no one would ask any questions. Unfortunately, midstream, right before one of the End-of- Sprint demonstrations, the customer informed the manager that is was necessary to change the requirements, as expectations had changed; congressional budgets had changed, and it was necessary to scale back on the capabilities to be delivered. Unfortunately, some of those capabilities were already done and folded into the demonstration that followed; capabilities that the waterfall, iterative sched- ule showed weren’t scheduled for months. Unfortunately for the manager, the agile development teams had decided that they were easier incorporated into the original software framework for the program/project and decided to add them in earlier. Had the manager acted like an agile manager and paid attention to what the agile development teams were actually producing, they would have known what was hap- pening. The emphasis was on showing a stable Earned Value Metrics, software pro- ductivity numbers were on track (not taking into account what capabilities were being coded), and things looked great to upper management. What was discovered was that the capabilities the customer had to have, had been placed on the backlog for later Sprints, meaning it wasn’t possible to scale back on the requirements, or cost estimate, or schedule estimate. The customer ordered an immediate Estimate- to- Complete, and discovered the inconsistencies in Earned Value reporting Metrics. The project was cancelled, the manager was fired, and it was a long time before the company successfully procured another contract.
I took a profound lesson away from that experience: If software developers couldn’t relate models to code, how in the world were nontechnical customers going to relate models to a finished application? The debates have raged for twenty-plus years about which form of system model—data flow diagrams, data models, object models, and so on—are most understandable to users. And the answer is: none of the above. Users relate to the real thing and the real thing only. Paper mock-ups and visual prototypes do serve as effective intermediate markers at times, but real progress is demonstrated only by working software. The principle “working software is the primary measure of progress” caused intense discussion among the Agile Manifesto authors. Questions ranged from what the term “working software” meant and whether it included prototypes and models to whether working software was the only measure and who got to measure. If we can’t show demonstrable, tangible progress to the customer, then we don’t really know if we are making progress. Data models, UML diagrams, requirements documents, use cases, or test plans may be markers that indicate some degree of progress (or at least activity), but these markers are not primary measures. Features that implement a portion of a business process, features that demonstrate that a piece of flight avionics software actually drives the required actuators, features that allow a doctor to extract and view a digitized CT scan—these are primary measures. Nothing else qualifies.
For example, shutting down multi-threaded programs gracefully and portably is hard. The problem stems from inconsistent thread cancellation semantics [Lew95] across operating systems, such as POSIX/UNIX, Win32, and real-time embedded systems like VxWorks or LynxOS. Similarly, support for advanced threading features, for example thread-specific storage (475), 'detached' threads [Lew95], real-time scheduling [Kan92], and scheduler activations [ABLL92] varies widely across operating systems. It is therefore infeasible to write portable concurrent applications by programming directly to the operating system APIs. General-purpose design patterns, such as Adapter [GoF95] and Wrapper Facade (47), can be applied to shield concurrent software from the accidental complexities of the APIs outlined above. In addition, off-the-shelf 'infrastructure' middleware [SFJ96], such as ACE [Sch97] and JVMs, is now widely available and has reified these patterns into efficient and reusable object-oriented operating system encapsulation layers. However, even after adopting this level of middleware many challenges remain, due to inherent complexities associated with concurrent application development, including:
Johannes Holvitie et al.  mentioned a major reason for the popularity of agile and lean software methods. It contributed to the technical debt discussion by showing differences in assumed and indicated technical debt knowledge. Also, components closest to implementation and its maintenance were supposed to have the most positive effects on technical debt management. Hassan Soltan and Sherif Mostafa et al.  explained lean concept focused on eliminating non value added activities while agile discovering and responding to uncertain changes of the market. Both concepts were able to achieve strategic objectives (competitiveness, productivity, profitability, and survival) through improving the overall performance. Many research suggested that combining lean and agile via decoupling point increases the organization benefits. Tomohiro Hayata et al.  described the agilesoftware development and lean architecture both had been examined in the software engineering field. Merging two approaches had also been investigated. The existing investigation and practices only present the principles but fail to develop a framework of the Software development. A framework developed about how primitive agile practices were fulfilled by introducing “lean” practices under the Data Context Interaction (DCI) paradigm. Lean practice was an end user-focused and value-centric system design.
Architectural refinement aims to help provide the degree of architectural stabili- ty required to support the next iterations of development. This stability is par- ticularly important to the successful operation of multiple parallel Scrum teams. Making architectural dependencies visible allows them to be managed and for teams to be aligned with them. The architecture refinement supports the team decoupling necessary to allow independent decision-making and reduce com- munication and coordination overhead. During the preparation phase, agile teams identify an architecture style of infrastructure sufficient to support the development of features in the near future. Product development using an arc- hitectural refinement most likely occurs in the preservation phase. Architectural refinement is one of the key factors to successfully scale agile. Describing and maintaining (through refinement) software architectural design enables a system infrastructure sufficient to allow incorporation of near-term high-priority fea- tures from the product backlog. The proposed softwarearchitecture methodol- ogy in agile environments allows the softwarearchitecture and design to support the features without potentially creating unanticipated rework by destabilizing refactoring. Larger software systems (and teams) need longer architectural re- finements. Building and re-architecting software takes longer than a single itera- tion or release cycle. Delivery of planned functionality is more predictable when the architecture for the new features is already in place. This requires looking ahead in the planning process and investing in architecture by including design work in the present iteration that will support future features and customer needs. The architectural refinement is not complete. The refinement process in- tentionally is not complete because of an uncertain future with changing tech- nology orientations and requirement engineering. This requires continuously extending the architectural refinement to support the development teams.
Chapter 1 is a general introduction that introduces professional software engineering and defines some software engineering concepts. I have also written a brief discussion of ethical issues in software engineering. I think that it is important for software engineers to think about the wider implications of their work. This chapter also introduces three case studies that I use in the book, namely a system for managing records of patients undergoing treatment for mental health problems, a control system for a portable insulin pump and a wilderness weather system. Chapters 2 and 3 cover software engineering processes and agile devel- opment. In Chapter 2, I introduce commonly used generic software process models, such as the waterfall model, and I discuss the basic activities that are part of these processes. Chapter 3 supplements this with a discussion of agile development methods for software engineer- ing. I mostly use Extreme Programming as an example of an agile method but also briefly introduce Scrum in this chapter.
Service oriented architecture (SOA) is one of the architecture methods that provide business operations Integration by using services [1, 2]. The services have the least dependencies with each other. So changing the service is done easily and the system magnifying would be also done in the best way. We can readily add some elements to software or eliminate some elements of it[ 2, 3,4]. As a result when the changes are high in the environment and there appear new requirements in the business and the enterprise needs to perform some changes, using this architecture would be helpful. On the other hand the agile methods of software development have been highly used in many projects because of their most advantages that have in comparison to the heavy weighted methods. Adopting the changes is one the principles of the agile methods that we would be introduced by these principles below. So using SOA in the agile methods could be helpful and profitable. Of course this is just one of the advantages of SOA [5, 6]. Indeed SOA is one of the architectures that are applied by the aim of decreasing information technology costs and improvement of agility in the enterprises . In the past it was believed that architecture and agility were two concepts completely different and on the opposite side of each other and could not
In this solution path, process practitioners targeted mainly agile methods’ ability to scale up and their applicability for large-scale systems. They used mixtures of agile practices with plan-driven practices to construct a hybrid framework, where agile practices are used where their advantages are maximized, and plan-driven practices are used where their strengths can be maximally inherited. In balancing agility and discipline, Bohem & Turner have introduced a risk-based approach to choose the right mix of agility and control in the development strategy used for a certain application . In the proposed approach, a risk-based analysis is used to decide on parts where agile risks dominate and others where plan-driven risks dominate. The amount of planning, architecting, prototyping and testing needed can be considered given the analysis results. As a result, parts can be considered, where risk-based agile process and those where risk-based plan-driven process can be applied. Bohem & Turner have applied their proposed framework on an agent-based planning system for national crisis management which is a very large highly critical system . This framework provided constant monitoring and evaluation to handle risks that can come up during development lifecycle. However, this framework may require experienced staff having different skills, can precisely measure possible risks, and can carefully merge agile practices with plan-driven practices in a way that best reflects the inherited advantages of both of these approaches.
One of the strength points of agile methodologies is that its philosophy which based on the idea that projects are developed in short iterations. At the end of each iteration the user can see a working version of the software before moving ahead to the next iteration which means that the overall project will be more flexible. In traditional methodologies if the customer changes some requirement after long period such as (six-ten month) this require complete project rebuilding, but through applying agile philosophy it can be adapted. Another strength point is that the customer can evaluate the development after each iteration and suggest plans for future. Another advantage of agile methodologies is the constant testing and integration since testing is done after each iteration which means that faults can be corrected regularly. Another strength point is that progress can be viewed and measured after each iteration.
Scrum  was also a very important player in the agile methods growth. Although it has its origins earlier than XP, it became widely known only around 2006 when the Scrum Alliance 9 (a nonprofit organization) became a corpo- rate entity and started a certification process to gather pro- fessionals that met their criteria. The alliance offers several certification stamps that can be given only by certified train- ers. Initially, all certifications given in Brazil were offered by foreign trainers in English. Since August 2008, though, the first Brazilian Certified Scrum Trainers were recognized by the Scrum Alliance and courses started to be taught in Portuguese. The certification filled an important gap for the industry as it presented a way to prove the knowledge of companies on agile methods. Since then other Brazilians obtained the CST certificate and the demand for certified scrum courses never stopped growing. Recently, a discussion regarding the certification led to the creation of another foun- dation (Scrum.org 10 ) separating Ken Schwaber (Scrum.org) and Jeff Sutherland (Scrum Alliance), and provoking a rup- ture in the Scrum community. This new association also offers a certification program under a different label (Pro- fessional Scrum Certifications).
Agile methodologies are used to handle the challenges of managing complex projects during the development phase. According to Hale 9 research, statistics results from a survey made to experts in Scrum and Kanban methods to compare their efficiency (means are not significantly different at 95% confidence level), showed little difference, at least to conclude that Scrum would be better than Kanba from the analysis of its effects in management factors of software development. Likewise, it suggest that Scrum and Kanban lead to successful projects and Kanban can be better than Scrum in terms of project management, and both can be used to handle budget management, risk control, project quality, amount of available resources, project scope and schedule control.
Abstract: Agilesoftware development methodology (ASDM) has become a more popular development method for software development, especially for web and startup companies. It has also been characterized differently from plan-based methodologies mainly because of its focus on adapting to change and delivering products of high quality through simple work processes. Agile adoption is nonetheless a complex task, and not all agile processes and practices are suitable for small-scale startups. There are some agile practices that have negative impact on startups. The failure of some startups is mainly caused by the failure to develop products due to the lack of adopting of proper development methodology. However, there is a lack of studies on factors that affect the selection or adoption of agile methodologies. This study therefore attempts to showcase the motivation rationale for agile adoption among software startups in Saudi Arabia. An online survey was conducted for software startups in the Kingdom of Saudi Arabia to elicit their responses on their motivations for adopting agile methodologies. The outcome reveals that the top five motivations for agile adoption are the need for accelerated product delivery, enhanced ability to manage changing priorities, increased software maintainability, simplified development process, and need for enhanced delivery predictability. This outcome will support startup companies, projects managers and development teams, ets.
This research uses literature to reason about the relationship between agile development methods and maintainability or usability. Future work can be done in order to validate the findings presented in this research, by setting up an experiment to specifically test the impact of development methods on maintainability or usability. Prior empirical research has not dealt explicitly with this relationship. Instead, most empirical research has focused on other specific aspects such as programmer productivity and error count, measured mainly for the short term. It would be interesting to measure the amount of hours required for maintaining a program developed using agile methods when compared to a program developed using a traditional plan-driven approach over a long time.
extreme programming (XP), agile methods put developers to work in small teams to tight budgets and short timescales. In contrast to traditional software development methods, agile developers liaise continuously with business clients, aiming to deliver working software as frequently as every two weeks during a project, and welcome changes to the requirement in response to evolving business needs. The concept of the Waterfall Process Model is that the requirement analysis has to be done in the beginning phase, whereas, the AgileSoftware Development emphasizes that the requirement is changeable throughout the process. Thus, it seems that using the AgileSoftware Development is becoming a trend for software development companies in order to improve the software process.
These models describe the various phases and the order of their execution to be followed to develop the software product 1 . Each phase produces deliverables that are fed as input to the next phase in the life cycle. The product generated by the last phase serves as the final product called as software product. Different models proposed so far are:
The main roles in Scrum: Scrum Masters: He or she is the leader of Scrum team, and ensures the team has a good operation, and helps the team to clean the obstacles of implementation; Product Masters: He or she determines the direction and vision of the product, and defines the contents of the product, and determines the priority and delivery time for product, and is responsible for the ROI of product; Scrum Team: It is a cross-functional small team, and the team composes of 5 to 9 people, and the team has the skills to develop available software.