<p>Denna kombinerade magisteruppsats i matematik och datalogi handlar om en metod för att hitta ett lokalt minimum för en unimodal funktion inom ett intervall genom användning av ett femtegradspolynom. Femtegradspolynomet skapas med hjälp av interpolation baserad på funktionsvärdena samt första och andra derivatans värden i intervallets ändpunkter. I rapporten härleds matematiskt att metoden konvergerar, följt av ett bevis för att metoden konvergerar med en konvergenshastighet av tre. Slutligen testas metoden mot två referensmetoder för att se användningsbarheten. För detta beskrivs vissa mjukvaruutvecklingsmetoder och några teststrategier. Testen utförs med sex olika funktioner och med tre olika versioner av metoden. Slutsatserna från testen visar att metoden inte är bättre att använda än referensmetoderna även om den har högre konvergenshastighet samt att metoden måste ta hänsyn till när den bara hittar nya approximationer på ena sidan av intervallet. Vi kunde även se från testerna att ingen av metoderna var bra på att ge en korrekt approximation, utan det finns behov av säkrare metoder för detta. Det är därför föreslaget i uppsatsen att man borde försöka att hitta ett annat interpolations-polynom för att förbättra metoden. Man borde även testa mot en metod som har högre konvergenshastighet. För att kunna göra det behöver man titta på andra sätt att representera numeriska värden och det skulle kunna vara intressant för att se om man då skulle få ett annat resultat.</p> / <p>This combined master thesis in Mathematics and in Computer Science deals with a method for finding the local minimum of a unimodal function inside a given interval by using a fifth degree polynomial. This fifth degree polynomial is created from the function value and the first and second derivative values in the end-points of the interval. In this report the presented method is derived mathematically to converge and it is then proven that the method has a convergence rate of three. Last is the method tested against two reference methods to see the usefullness of the method. To do this some software development methods are described in the report and some test strategies are given. The tests are done with six different functions and with three different implementations of the method. The conclusions from the tests are that it is often better to use one of the referencemethods instead of the presented method, even if the presented method has a better convergence rate, and that the method needs to handle when the found approximation always is on one side of the interval. We could also see from the tests that none of the methods were good on finding a correct approximation. Therefore, there exist needs for more secure methods. It is therefore suggested in the report that a search for other interpolating functions ought to be carried out in order to improve the method. Also, it could be interesting to test against another method with even higher convergence rate. To do that, another numerical representation is needed and it would be interesting to see if that changes the outcome</p>

Am 15. November 2010 fand an der Universitätsbibliothek Leipzig ein Strategieworkshop mit dem renommierten Informationsexperten Marshall Breeding von den Vanderbilt University Libraries in Nashville statt. Breeding ist „Director for Innovative Technologies and Re search“ – entsprechend stand seine einführende Präsentation unter dem Titel „Advancement of Technology Strategies“. In seinem Vortrag umriss Breeding die gegenwärtige softwaretechnische Situation von Bibliotheken und arbeitete dabei Besonderheiten der deutschen Bibliothekslandschaft heraus. Laut Breeding werde der deutsche Markt insgesamt noch immer von traditionellen mittelständischen Anbietern von Integrierten Bibliothekssystemen (ILS) beherrscht, wobei aber internationale Großfirmen zunehmend signifikante Marktanteile gewinnen. Im Gegensatz dazu teilen sich letztere in den USA den Markt im Wesentlichen bereits auf, ohne dass ein Anbieter klar dominiere. Besonders an den öffentlichen Bibliotheken sei ein Trend zu quellcodeoffenen Systemen (Open-Source-Systeme) zu verzeichnen.

Graphical modeling is becoming an increasingly important part of software engineering as it provides means of increasing productivity by raising the level of abstraction in software devel-opment. One of the most widely adopted modeling notations is the Unified Modeling Language (UML) which has gained popularity due to its generality and broad applicability. Despite its advantages, this general purpose notation is burdened with the lack of purpose specific model-ing abstractions. The modeling abstractions in the language lack specialized properties and thus models might not precisely express the intentions of the modeler. In consequence, this leads to ineffectiveness of using models in UML. This thesis presents research aimed at improving modeling with UML. By exploiting the language customization mechanisms inherent in UML – stereotypes and profiles – the research presented in the thesis explores such aspects of improving modeling as creating language cus-tomizations or using a customized modeling language. The context, in which the modeling is considered, is delineated by the principles of model driven software development (MDD). The principles recognize the usage of models as the primary artefacts in software development thus providing a solid foundation for considering the use of models in software development. One of the contributions in the thesis is the identification and definition of factors determin-ing the successful realization of MDD in industry. These factors provide means of positioning language customization in the forefront of MDD. Another contribution in the thesis is eliciting and prioritizing a set of criteria for choosing between language customization mechanisms, which is a result of another industrial case study. A series of experiments in academic and industrial environments showed the magnitude of improvements to be expected after replacing a standard modeling language with a customized modeling notation. This series of experiments provided a basis for experimenting with stereo-types and software inspections which indicated a considerable increase in effectiveness of the reading techniques used in software inspections after replacing a standard notation with a cus-tomized one. The results from all empirical studies affected the development of quality assessment crite-ria for stereotypes. The criteria and the exploration of several existing profiles led to the devel-opment of guidelines for creating “good” stereotypes by analyzing existing UML profiles. An additional contribution in the thesis is exploring the usage of an alternative mechanism to stereo-types – model libraries – for adaptation of a modeling language. The way in which model librar-ies can be created in an efficient way is studied by creating a method for extracting knowledge from ontologies into UML domain models. The results of the research presented in the thesis show how to improve modeling with UML by customizing the language with stereotypes. The main contribution is the exploration and evaluation of issues related to creating language customizations and using the customized language.

Information Technology (IT) is inextricably tied to financial services; the business can no longer view IT as simply a part of discretionary spending. More particular to the financial services industry, technology is a way to gain competitive advantage through innovation. Financial services companies discover ways to utilize technology in order to generate product and process innovation, for example, consider the innovation to use scanners and, more recently, smart phones to deposit checks from home or elsewhere instead of with an ATM or a teller at a brick and mortar bank. As the market becomes more competitive, financial services companies must rely even more on product and process innovation. A key enabler of this innovation is the ability to fully understand the current state of how business value is delivered through the use of IT. This understanding can in turn help financial services companies to plan more effectively both strategically and tactically as the environmental factors change constantly. As companies spend vast amounts of money on projects, it is imperative to understand how ideas flow through a life cycle and are ultimately realized by some process or product offering that in turn deliver some value to the business. The goal of IT for the business is often stated as an improvement in triumvirate: better, faster, cheaper. The difficulty with this goal is that these facets are often mutually exclusive. How then, can IT deliver? This thesis will examine how one financial services company may improve its software project delivery process by examining its historical and current operating state and then discussing some recommendations to achieve improvement. / text

Control and flexibility may appear an unlikely pair. However, I propose that effective management of dynamic environments, such as systems development under conditions of uncertainty, must still provide clear control mechanisms to manage the progress and quality of the resulting products. This dissertation presents research to understand the types of control used in the context of flexible software development processes. The dynamic capabilities extension to the resource-based view of the firm is used to understand dynamic environments. Within those environments, control theory is used to understand how activities are guided and controlled to achieve management objectives. Specifically, control theory acts as a lens to contrast the control mechanisms found in plan-driven and flexible processes. I extend current thinking to include emergent outcome controls for team coordination in a taxonomy of control mechanisms. These phenomena are studied through a qualitative field study. The results show that organizations will choose more flexible management approaches as uncertainty increases, and that more controlled-flexible approaches managed with emergent outcome controls will lead to better outcomes than uncontrolled, ad hoc approaches.

M. Tech. Business Information Systems / This mini-dissertation explored the e-Skills expectation gap between academia and the software industry where there are high numbers of unemployed graduate in the face of ICT skills shortage. This study looked at the following factors: government participation in the industry, academia course offering, course design and processes, and individuals as e-Skill contributors to the software industry. The present study conceptualises a framework that may help bridge the gap between academia and the software industry. The study sought to analyse the ICT curriculum, student e-Skills and the software industry, in order to address the present e-Skills gap.

We introduce a class of program editors that present a program using a rich set of transformations; we call these kinds of editors composable presentation editors. Proper use of these kinds of editors appears to lead to more expressive programs-programs whose structure are aligned with the problem they are trying to solve. By default, the composable presentation editor presents program elements textually as concrete syntax and enables typical editor commands on the program. Metadata on program elements control how the transformations are applied. Customized metadata can re-order, pictorialize, collapse, duplicate, or expand the displayed form of program elements and can additionally alter the available editor commands. We have developed a set of presentation techniques to be used by presentation designers (i.e., the programmers who design how a program is presented in the editor. These techniques relate to well-understood programming language design, editor design, and programming best-practices techniques including scoping, higher order functions, refactoring, prettyprinting, naming conventions, syntax highlighting, and text hovers. We introduce two implementations of composable presentation editors and a number of examples showing how programs can be made more expressive when presentation techniques are properly used. The first implementation is the ETMOP, an open editor, where a metaobject protocol is provided that allows language and editor designers to customize the way program elements are displayed. These customizations are called presenta- tion extensions and the corresponding presentation extension protocol acts in a way similar to the way that syntax macros extend the syntax of a language. The second implementation is Embedded CAL, a closed editor that uses these presentation techniques to embed one language (CAL) inside a host language (Java) through the use of presentation techniques, without changing the syntax or compiler of either language.

Developing a large software system involves many complicated, varied, and inter-dependent tasks, and these tasks are typically implemented using a combination of defined processes, semi-automated tools, and ad hoc practices. Stakeholders in the development process --- including software developers, managers, and customers --- often want to be able to track the actual practices being employed within a project. For example, a customer may wish to be sure that the process is ISO 9000 compliant, a manager may wish to track the amount of testing that has been done in the current iteration, and a developer may wish to determine who has recently been working on a subsystem that has had several major bugs appear in it. However, extracting the software development processes from an existing project is expensive if one must rely upon manual inspection of artifacts and interviews of developers and their managers. Previously, researchers have suggested the live observation and instrumentation of a project to allow for more measurement, but this is costly, invasive, and also requires a live running project. In this work, we propose an approach that we call software process recovery that is based on after-the-fact analysis of various kinds of software development artifacts. We use a variety of supervised and unsupervised techniques from machine learning, topic analysis, natural language processing, and statistics on software repositories such as version control systems, bug trackers, and mailing list archives. We show how we can combine all of these methods to recover process signals that we map back to software development processes such as the Unified Process. The Unified Process has been visualized using a time-line view that shows effort per parallel discipline occurring across time. This visualization is called the Unified Process diagram. We use this diagram as inspiration to produce Recovered Unified Process Views (RUPV) that are a concrete version of this theoretical Unified Process diagram. We then validate these methods using case studies of multiple open source software systems.

Requirements management is an important part of the software development process. The success of a project may depend on how this is handled. Even though several research studies indicates that more attention should be paid on non-functional requirements, the primary focus in practical projects still regards identifying functional requirements. Especially the prioritization of the non-functional requirements has been proven to be of great importance for the success of a project. This report investigates basics in agile requirements management involving opinions from experts from a software development company. This is done with help of existing literature and interviews with key actors involved in prioritization at the company. I investigate prioritization of non-functional requirements and possibilities for agile project development. The results contribute to developing an overall understanding of the agile way of working. The methodology of this report follows a qualitative approach. It is based on secondary data from literature and documents, but also on data collected via interviews. The results are acknowledging earlier findings from the literature and illustrate with examples actual prioritization of non-functional requirements, and how and why prioritization is a complex activity at a company. However, according to one of the most important findings of this study, the strict use of prioritization techniques is not the most urgent necessity for the success of a project. / Kravhanteringen är en viktig del av systemutvecklingsprocessen. Ett projekts framgång kan kopplas till hur detta genomförs. Även om flera studier pekar på att mer uppmärksamhet bör läggas på icke-funktionella krav är den primära fokusen i flera projekt fortfarande att identifiera funktionella krav. Speciellt prioriteringen av de icke-funktionella kraven har visat sig vara av stor betydelse för ett lyckat projekt.  Den här rapporten undersöker grunderna i den agila kravhanteringen som involverar åsikter från experter i ett företag inom mjukvaruutveckling. Detta görs med hjälp av befintlig litteratur samt intervjuer med nyckelaktörer involverade i prioriteringen hos företaget. Jag undersöker prioriteringen av icke-funktionella krav och möjligheter för agil projektutveckling hos företaget. Följaktligen kommer resultatet bidra till att ge läsaren en allmän förståelse om det agila arbetssättet. Metodologin för den här rapporten följer ett kvalitativt tillvägagångssätt. Den baseras på sekundär data från litteratur och dokument, men även data insamlat via intervjuer. Resultaten medger tidigare upptäckter från litteraturen och visar med exempel verklig prioritering av icke-funktionella krav samt hur och varför prioriteringen är en komplex aktivitet hos ett företag. Dock är, enligt en av de viktigaste upptäckterna i den här rapporten, ett strikt användande av prioriteringstekniker inte den viktigaste nödvändigheten för ett lyckat projekt.

Frames sind parametrisierte Elemente zur Erzeugung von Programmen in einer beliebigen Zielprogrammiersprache. Ihre Handhabung ist einfach und schnell zu erlernen. Allerdings findet bei Verwendung von Frames eine “Verunreinigung” des Programmcodes, der als Basis für die Generatorentwicklung dient, mit Befehlen der Generatorsprache statt. Dies erschwert die Weiterverwendung der gewohnten Entwicklungsumgebung für die Zielprogrammiersprache. Eine eventuelle Weiterentwicklung der Programmbasis muss anschließend in Form von Frames erfolgen. Im Rahmen dieser Arbeit erfolgt die Beschreibung noninvasiver Frames, bei denen Informationen zur Position der Frames getrennt vom Programmcode aufbewahrt werden. Ihre Vermischung erfolgt in einem separaten Schritt zur Darstellung oder zur eigentlichen Codeerzeugung. Der Prozess der Generatorentwicklung auf der Basis noninvasiver Frames passt sich gut in die Prozesse von Merkmal-orientierter (FOSD) und Generativer Softwareentwicklung (GSE) ein, weil noninvasive Frames die automatisierte Prüfung aller mit dem Generator erzeugbaren Programme hinsichtlich Syntax und bestimmter semantischer Eigenschaften unterstützen und die Generierung durch Auswahl der gewünschten Programmeigenschaften ermöglichen. Die Machbarkeit der Entwicklung von Softwaregeneratoren mit noninvasiven Frames wird anhand zweier Fallstudien demonstriert.