|
|
| home about us free pdf software downloads links privacy site map copyright policy |
|
|
The Effective Software Development Series (ESDS) provides expert advice on all aspects of modern software development.http://www.aristeia.com/ESDS/ESDS_overview.pdf. Books in the series are well-written, technically sound, of lasting value, and tractable length. Each describes the critical things the experts almost always do — or almost always avoid doing — to produce outstanding software. Scott Meyers (author of the Effective C++ books and CD) conceived of the ESDS and acts as its consulting editor. Authors accepted into the series work with Meyers and with Addison Wesley's professional editorial staff to create essential reading for software developers of every stripe. • Expert Advice — Effective software development calls for knowing what to do, how to do it, and why to do it that way. • All Aspects — Most book series focus on a particular area of software development, e.g., coding in Java or programming for Windows. If professional software developers deal with it, the series covers it. Books in the Effective Software Development Series generally run no more than 300-400 pages. • Outstanding Software — Too much software is best described as “serviceable.” Users can get it to do what they want it to do, and software developers can enhance it in modest ways, but neither users nor software developers find working with it particularly rewarding. Outstanding software does what it does so well, users enjoy working with it. Software developers, too, are enthusiastic, because the software is easy to modify, easy to extend, and elegant in how it accomplishes its tasks. Books in the ESDS explain how to write outstanding software. The ESDS welcomes all approaches that give ... Visualizations of software changes are presented that complement existing visualizations of software structure.http://www.niss.org/technicalreports/tr113.pdf. Linked by selection mechanisms, multiple views are combined to form perspectives that both enable discovery of high-level structure in software change data and allow effective access to details of those data. Use of the views and perspectives is illus-trated in two important contexts: understanding software change by exploration of software change data and management of software development. In an ideal world, software architecture would anticipate and facilitate future changes. We have developed a number of visualization tools, which not only facilitate rapid exploration of high-level structure in software change data, but also serve as a powerful visual interface to the details of the data. The second problem is Management of Software Development, for which precise, quantitative results of formal analyses may be less important than the rapid, qualitative understanding of the current status of a development project that visualizations afford. The setting for our research, the software change process and the data are summarized in §2. Our definition of a change to software is data-driven: a change is any alteration to the software recorded in the change history database. More than 10,000 software developers have participated in the project over the last fifteen years. Though the need for visualization is especially acute for projects of this magnitude, our visual tools are broadly and widely applicable within the software development process. This level of detail preserves the capability to build earlier ... Abstract: Agile and model-driven development exhibit different constraints with respect to how products should be developed that make the two difficult to reconcile under all circumstances.http://www.softmetaware.com/oopsla2002/wegenerh.pdf. Model-driven development is most affected by a lack of guaranteed congruence between model and implementation, which can be the result of an agile approach. On the other hand, the model-driven approach tends to defer or complicate feedback, which is critical to agility. Agile and model-driven development can be considered en vogue. Reconciling both approaches requires understanding their structural differences; this position statement analyzes those differences. Agile development is not based on a rigid execution structure but malleable values. Values are put into practice by following a set of principles that are adapted to the specific needs of the environment. Specification: An object-oriented domain model and the execution specification are designed in UML; the software is directly generated from there with no manual programming involved. In accordance with Dzida and Freitag [1], we understand the problem of validating analysis and design as an incremental, evolutionary process of negotiation and finding mutual agreement on the basis of the realized software. The task sequence and workflow required to develop the software cannot be predicted and may not be restricted in advance. Model-driven development is based on the design of a software system in UML. Unless the software is fully generated from a UML specification, manual work will have to be performed at the solution domain level. Model-driven development revolves ... The purpose of this paper is to describe a well-defined methodology for the development of safety-critical software using industry standards.http://www.adaworld.com/pdfs/criticalsafetyada.pdf. The standards provide guidelines for development and control of software and may be adapted and tailored to fit an organization’s particular needs. Unless constrained by a contract each organization is allowed to establish its own procedures, methods, tools, and environments for the software development project. The purpose of the software planning process is to define how the software product will be developed. DO-178B: “The software requirements process uses the outputs of the system life cycle process to develop the software high-level requirements. When a system requirement is allocated to software, the developer may simply reference the system requirements without re-writing it; thereby reducing work and the risk of introducing inconsistencies. New software requirements will be derived from system architectural design. Constraints are restrictions placed on the software and a project decision is required to determine how the constraints will be implements. Show below is the system to software requirements traceability table. The StP Life Cycle Desktop also generates software to system requirements traceability tables showing the software requirements allocated to the system requirements. Derived software requirements will not trace to system requirements. Traceability analysis will determine the completeness of the mapping of system requirements to software. In this example the system name represents a software component which is a non-trivial, nearly independent, and ... Namely, the thought of software standards as an integral part of a methodology was foreign to most engineers.http://www.crispen.org/Bob/structural_model.pdf. The reason for this lack of standards is di-rectly attributable to the software languages being employed. As Ada has become more and more the language of choice, the inclusion of software standards within a software methodology has grown. A structural model is new to the software pro-cess and falls directly out of a systems engineering process as it is applied to Ada software development. It should be specific enough to give guidance but be general enough to apply to most software situations. The systems approach to software development concentrates on the total system over its whole lifecycle. Quality characteristics define the attributes that the software must ex-hibit in order to reach the software goals. The software standards component of the methodology pro-vides for consistency in the software development process. They can be treated as a minimal requirements set for a software design methodology. Then at the end of the program these guides will be the most impor-tant documents in the maintenance of the software system. With this in mind, it is astonishing that system software has done such a poor job of modeling interfaces. This common global data approach has been a large source of error in most software systems that use it. For software to be-come functional without extensive wasted effort, the interfaces within the system must be both defined and controlled. An architectural map for a software program or domain is es-sential to the production of quality software. It must be a stan-dard with which to ... How much did it cost you last year to adapt your software portfolio to work with new versions of compilers, database managers, or operating systems? 3.http://www.processimpact.com/articles/metrics.pdf. Are the efforts you devote to improving software quality reducing the time you must spend correcting bugs? 8. Many software engineering organizations will find it difficult to provide quantitative answers to these questions. Two of his categories are work profile and work distribution metrics, both of which pertain to the ways in which software work is distributed among different development and maintenance activities. This article describes the experience of a small software group that supports an industrial research organization. By tracking trends in the distribution of these activities, we have improved our understanding of how we develop software. Collecting work profile and work distribution metrics has become a part of our software engineering culture. It is not as difficult as you might think, and the lessons you can learn from the data constitute a valuable tool in your continuing quest for improved software quality and productivity. Most software work can be classified into one of these ten domains, regardless of the life cycle model being used. Reporting Options The work effort metrics we collect belong to the team members, not to the supervisor or the software process zealot in the group. The fraction of our total software work devoted to defect correction has dropped from 13.5% in the first quarter of 1990 to a steady state of less than 2%. But no one is immune from version N+1 of the commercial software products they use, nor from the need ... Patterns capture expert knowledge about “best practices” in software design in a form that allows that knowledge to be reused and applied in the design of many different types of software.http://www.perfeng.com/papers/antipat.pdf. Antipatterns document common mis-takes made during software development as well as their solutions. Patterns capture these proven solutions and package them in a way that allows software designers to look-up and reuse the solution in much the same fashion as engineers in other fields use design handbooks. A pattern language is a collection of patterns that may be combined to solve a range of problems within a given appli-cation domain, such as architecture or software development. Antipatterns address software architecture and design as well as the software development process itself. This is a supplement to software performance engineering that will improve the architec-tures and designs of software developers. We also propose three new performance antipatterns that often occur in software sys-tems. While their emphasis is different, both patterns and antipatterns address common software problems and their solutions. As noted in the introduction, this work is aimed at capturing expert software design knowledge. While they were published before the work on software patterns began and presented with a different focus, they can be viewed as performance patterns. This paper extends the work on antipatterns to explicitly address the performance of software architectures and designs. The software analogy to the One Lane Bridge is a point in the exe-cution where one, or only a few, processes may continue to execute concurrently. The value ... In particular, we describe the basic concepts on which Tro-pos is founded and the types of models one builds out of them.http://www.jamesodell.com/AOSE02-papers/aose02-23.pdf. We also specify the analysis process through which design flo ws from external to system actors through a goal analysis and delegation. In addition, we provide an abstract syntax for Tropos diagrams and other linguistic constructs. New application areas such as eBusiness, application service provision and peer-to-peer computing call for software systems which have open, evolving architectures, operate robustly and exploit resources available in their environment. We expect that many will be turning to multi-agent system technologies and methodologies for guidance and support in building the software systems of the future. The phases covered by the proposed methodology are as follows. Notice that the notion of actor in Tropos is a generalization of the classical AI notion of software agent. This model provides the basis for capability modeling, an activity that will start later on during the architectural design phase, along with the mapping of system actors to software agents. These are the points where the designers of the software system will use their creative in designing the system-to-be. As indicated in the introduction, the most important feature of the Tropos methodo-logy is that it aspires to span the overall software development process, from early requirements to implementation. While Tropos covers the full range of software development phases, it is at the same time well-integrated with other existing work. It is interesting to note that much of the Tropos methodology can be combined ... This product group at Trimble is typical of the homegrown approach to agile software development methodologies.http://www.jimhighsmith.com/articles/cross_oct02.pdf. While interest in agile methodologies has blossomed in the past two years, its roots go back more than a decade. Because of the breadth of agile approaches and the people who prac-tice them, this is not as easy a question to answer as one might expect. I will try to answer this question by first focusing on the sweet-spot problem domain for agile approaches. Furthermore, truly repeatable process-es would be almost mechanical in nature, and no mechanical process could possibly react to the infinite variety of variations that software projects encounter. Certainly the FDD process contributed to the project’s success, but when I asked De Luca what made the FDD successful, his first response was that the overriding assumption behind the FDD is that it embraces and accepts software develop-ment as a decidedly human activity. Authors of all of these approaches (except LD) participated in writing the Agile Software Development Manifesto [2] and so its principles form a common bond among practitioners of these approaches. LD initiatives focus on accelerating the speed of delivering software applications, but not at the expense of higher cost or defect rates. There has been so much written about XP’s practices that another rehash seems less important than discussing XP’s impact on software development. They are finding new ways to deliver high-quality software faster and more flexibly. Other important contributions of XP proponents are their views on reducing the cost of change during a software’s life and their emphasis ... Abstract We argue that operational modeling and analysis of software systems offers an attractive avenue for improving both the productivity of software engineers and the quality of the control-intensive software they produce.http://www.reactive-systems.com/papers/esda.pdf. (RSI) in support of Embedded Software Design Automation (ESDA), an emerging discipline that provides modeling and analysis tools for developers of embedded software. RSI expects that ESDA will make embedded-software development much more like the processes followed in more established engineering disciplines such as electrical, mechanical, and aerospace. In contrast, the use of rigorous modeling techniques in the development of software remains virtually non-existent. Current software-development practice largely relies on in-formal approaches such as code review and testing to ensure that a system implementation adheres to its requirements. The high costs of software development, the frequency with which software-development projects fail, and the relatively low quality of many software products, may be attributed in part to this lack of formalized design support for software. Traditional Computer-Aided Software Engineering (CASE) tools provide some assistance, but only at the level of project management and design documentation. software can be found in the recent emergence of mathematically precise, yet operational and hence easy-to-grasp, approaches to modeling systems and efficient techniques for validating such models. Control-intensive software is found prominently in embedded applications such as automobiles, cardiac pace-makers, aircraft and cell phones; RSI is developing a collection of ... When interviewing candidates for programming jobs, one of my favorite interview questions is,“How would you characterize your approach to software develop-ment?” My favorite answer came from a candidate who said, “During software design, I’m an architect.http://www.stevemcconnell.com/ieeesoftware/ArtScienceEngineeringI.pdf.While I’m de-signing the user interface, I’m an artist. I like to pose this question because it gets at a fun-damental issue in our field: What is the best way to think of software development? Software development is art. But the proper question is not “What is software development?” but rather “What should software development be?” As David Parnas points out, in other technical fields the engineering profes-sions were invented and given legal standing so that customers could know who was qualified to build technical products (“Software Engineering: An Unconsummated Marriage,”Software Engineering Notes, Nov. 1997). Some people object to the idea that software de-velopment should be treated as engineering because they think “software engineering” is just a buzzword; they argue that no core body of knowledge can be identified as “software engineering.” There is no in-herent “right” or “wrong” quality level for software in-dependent of the specific software package being created. All other engineering fields are self-accredited and self-regulated; software developers will either volun-tarily swallow the medicine of software as engineer-ing or we will have it forced down our throats. A major distinction between software engineering and other kinds of engineering is that software is so labor intensive that a significant amount of engineer-ing energy must be focused ... eployed software is continuously under misuse or attack.http://www.securityinnovation.com/pdf/secure--begins-development-cio-june06.pdf. Whether it’s an internal application or a public-facing website, software vulnerabilities cause headaches for both the teams that build applications and the teams that manage them. Though there are many risk mitigation options for the software management lifecycle (firewalls, intrusion detection/prevention systems, etc.) these don’t address the root cause of the problem– a software development lifecycle that is not integrating security at each phase. Perimeter defenses are simply unable to stop most software attacks, because abusers are focusing on the application layer, shying away from attacks against the system and networking layer. Only a concerted effort by the software development team to produce more secure applications will protect you from exploitation. Secure applications are a software development challenge that will never be solved until security is addressed A “successful application” used to be defined as an application that solved the problems it was designed to solve, and did so with some reasonable performance. From a business standpoint, however, this definition must be rethought. Not because performance alone is a poor objective; but rather, because applications can be leveraged to exploit and destroy your business model – the very model you’re building it to assist! – and this must be considered during development. Though applications can be “retrofitted” for security post-deployment, this is a very expensive and ineffective approach. He is a seasoned software executive with successful business experience in various-sized organizations that serve ... he main driver behind software development has always been functionality.http://www.securityinnovation.com/pdf/regulatory-compliance-developers-cio-dec06.pdf. Software is meant to provide new or expanded access to data and services, and the requirements for software are typically written with these needs in mind. Data privacy and integrity, which are often neglected in functional specs, have become non-negotiable business requirements, largely due to regulations that developed in the wake of public exposures over the last five years. These new regulations require that software behaves differently, specifically, in the way that it identifies users, stores sensitive data and records access to system resources. Due to the volume and complexity of regulations, translating their intent and impact into software development is often frustrating for development teams. Let’s look at a few of the most common regulations, explore their impacts on the software development lifecycle, and determine how to handle them as senior managers of information: These provisions are of primary concern to software teams since they 2/4 Regulatory Compliance for Software Development Teams The transformation of the requirements into software is naturally complex, and the multiple points of contact with the data demand that the applications themselves be analyzed for consistency in protecting that data. Understanding compliance can be difficult, and there are very few resources that map regulatory requirements to software development or management requirements. However, the difficulty in 3/4 Regulatory Compliance for Software Development Teams Relate the business requirements to your software development process at every phase ... My favorite answer came from a candidate who said, “During software design, I’m an architect.http://www.stevemcconnell.com/psd/04-SoftwareEngineeringNotCS.pdf. I like to pose this question because it gets at a fundamental issue in our field: What is the best way to think of software development? We have a long tradition in the software field of debating whether soft-ware development is art or science. People who advocate programming as art point to the aesthetic aspects of software development and argue that science does not allow for such inspiration and creative freedom. Software development is art. But the proper question is not “What is software development currently?” but rather “What should professional software development be?” In my opin-ion, the answer to that question is clear: Professional software development should be engineering. With only about percent of software developers holding computer science degrees and practically none holding degrees in software engineer-ing, we shouldn’t be surprised to find people confused about the differ-ence between software engineering and computer science. The distinction between science and engineering in software is the same as the distinc-tion in other fields.1 Scientists learn what is true, how to test hypotheses, and how to extend knowledge in their field. The software job market has been growing faster than the educational infrastructure needed to support it, and so more than half the people holding software development jobs have been educated in subjects other than software. Because labor cost makes up such a large part of total lifetime software costs, software projects need to focus more on optimizing project goals than other kinds of ... | |
