<p>With the increased use of computers in every-day live, the demand for newer and better software is increasing day by day. This advancement has resulted in that many developers are searching for ways to decrease their development time. One approach is to use design patterns when designing applications. Design pattern are acknowledged solutions to known design problems that can be reused over and over again without ever doing the same thing twice. The most recent advancement of identifying design patterns has been within the domain of concurrent systems.</p><p>Design pattern within concurrent systems are of interest in this project because of its young age. Development of concurrent applications has often been compared to constant reinvention of the wheel, because code reuse is very low and solutions to design problems are being rediscovered over and over again. By using design pattern, an attempt is made to avoid that. The question is if design patterns are capable of standing under that load.</p><p>This project takes as a case study the problem of protecting a shared resource in a concurrent application, and implements two different solutions to that problem using a special design pattern. These two implementations are then evaluated, with consideration to certain software quality attributes, in a qualitative way.</p><p>This project shows how a pattern can be used to solve a common synchronization problem. It discusses the nature of design patterns, what needs to be considered when they are implemented and how a pattern language can affect the implementation.</p>

With the increased use of computers in every-day live, the demand for newer and better software is increasing day by day. This advancement has resulted in that many developers are searching for ways to decrease their development time. One approach is to use design patterns when designing applications. Design pattern are acknowledged solutions to known design problems that can be reused over and over again without ever doing the same thing twice. The most recent advancement of identifying design patterns has been within the domain of concurrent systems. Design pattern within concurrent systems are of interest in this project because of its young age. Development of concurrent applications has often been compared to constant reinvention of the wheel, because code reuse is very low and solutions to design problems are being rediscovered over and over again. By using design pattern, an attempt is made to avoid that. The question is if design patterns are capable of standing under that load. This project takes as a case study the problem of protecting a shared resource in a concurrent application, and implements two different solutions to that problem using a special design pattern. These two implementations are then evaluated, with consideration to certain software quality attributes, in a qualitative way. This project shows how a pattern can be used to solve a common synchronization problem. It discusses the nature of design patterns, what needs to be considered when they are implemented and how a pattern language can affect the implementation.

Many software development projects were not able to meet their deadlines with expected qualities under budgets. Basically, it was because the stakeholders and the de-velopment team sharing different expectations and misunderstanding the essence of how software was built. In most cases, the budget and resources were allocated according to the Functional Requirements, which described the features about the software. But on the contrary the development teams were striving in making decision about how to mitigate those Non-functional Requirements which were not included in the budget during the development cycle. However, to mitigate the Non-functional Requirements is not without a price, and letting development team impose resources arbitrarily will make software budget estimation more complicated and worse. This research pointed out what Non-functional Requirements should be abides by the international standard ISO 9126, offered a relatively accurate budget estimation framework. The framework showed how the stakeholders and the development team reach the consensus about the software, how to integrate with Cost Accounting to monitor the budget distribution and to implicate how software should be scheduled and estimated the cost for next coming projects.

Software product lines provide the opportunity to improve productivity, quality and time-to-market of software-based systems by means of systematic reuse. So as to accomplish systematic software reuse, elicitation of commonality knowledge is to be upheld by the analysis and management of variability knowledge inherent in domain requirements. Considerable effort is devoted to the management of functional variability, often neglecting the impact of quality concerns originating from non-functional requirements. In this thesis, a hybrid approach concentrating on the modeling of quantitative as well as qualitative concerns on quality has been proposed. This approach basically aims to support the domain design process by modeling non-functional variability. It further aims to support application design process by providing trade-off selection ability among quality concerns to control functional features that belong to the same domain. This approach is implemented and evaluated on an example domain to reveal its benefits on non-functional variability.

As software systems become increasingly larger and more complex, the need to make them easily maintained increases, as large systems are expected to last for many years. It has been estimated that system maintenance is a large part of many IT-departments’ software develop­ment costs. In order to design a complex system to be maintainable it is necessary to introduce structure, often as models in the form of a system architecture and a system design. As development of complex large-scale systems progresses over time, the models may need to be reconstructed. Perhaps because development may have diverted from the initial plan, or because changes had to be made during implementation. This thesis presents a reconstructed documentation of a complex large-scale system, as well as suggestions for how to improve the existing design based on identified needs and insufficiencies. The work was performed primarily using a qualitative manual code review approach of the source code, and the proposal was generated iteratively. The proposed design was evaluated and it was concluded that it does address the needs and insufficiencies, and that it can be realistically implemented.