By Topic

Software, IEEE

Issue 5 • Date Sept.-Oct. 2007

Filter Results

Displaying Results 1 - 25 of 28
  • [Front cover]

    Page(s): c1
    Save to Project icon | Request Permissions | PDF file iconPDF (2984 KB)  
    Freely Available from IEEE
  • [Advertisement]

    Page(s): c2
    Save to Project icon | Request Permissions | PDF file iconPDF (1629 KB)  
    Freely Available from IEEE
  • [Advertisement]

    Page(s): 1
    Save to Project icon | Request Permissions | PDF file iconPDF (2327 KB)  
    Freely Available from IEEE
  • Table of contents

    Page(s): 2 - 3
    Save to Project icon | Request Permissions | PDF file iconPDF (510 KB)  
    Freely Available from IEEE
  • [Advertisement]

    Page(s): 4
    Save to Project icon | Request Permissions | PDF file iconPDF (1156 KB)  
    Freely Available from IEEE
  • Tips for Software Authors

    Page(s): 5 - 7
    Save to Project icon | Request Permissions | PDF file iconPDF (151 KB)  
    Freely Available from IEEE
  • The Relevance of Architecture

    Page(s): 8 - 9
    Save to Project icon | Request Permissions | PDF file iconPDF (42 KB)  
    Freely Available from IEEE
  • Who Needs Evidence, Anyway?

    Page(s): 10 - 11
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (119 KB) |  | HTML iconHTML  

    In daily life, we face any number of problems and what seems like an ever-increasing list of possible solutions. The process of building and acquiring software is equally fraught with momentous decisions. However, the infrastructure to help people make informed decisions isn't as well developed. There's certainly no dearth of advertisements for new and improved ways of doing things, nor do we lack vendors' testimonials that their tool, approach, or methodology will solve the big problems. And a lot of people make decisions by hearing what solutions have worked for other people, whether around the water cooler or on discussion boards. Still, we usually can't easily access a helpful set of evidence from other folks, covering many of the decisions that we'd like to make. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Ajax Frameworks in Interactive Web Apps

    Page(s): 12 - 14
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (653 KB)  

    Asynchronous Web pages, which can change some of their content without reloading the whole page, have gained popularity recently. Although asynchronous pages are more difficult to store and access, and they complicate the browser's "Back" button operations, they support more flexible content presentation and thus enhance page performance. Ajax is a widely used technique to create such Web pages. The authors look at frameworks that help one work with Ajax. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Designing Extensible Classes

    Page(s): 15 - 17
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (131 KB)  

    This paper discusses about the design of extensible classes. Designers seek design rules that guarantee well-formed class hierarchies, appropriate interfaces, and easily extensible classes. Unfortunately, the detailed design of extensible class hierarchies is filled with nuanced reasoning. Building clean abstractions with clearly defined extension points is satisfying, but the best design choice isn't always obvious. How much access should you give a subclass to a class's inner workings? How much freedom should you give a subclass designer to "bend" inherited behaviors to make a new abstraction fit in or to extend an existing one? These decisions involve nuanced reasoning. The contract between a class and its subclasses requires thoughtful design, experimentation, and careful specification. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The Economics of Architecture-First

    Page(s): 18 - 20
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (799 KB)  

    Architecture is an artifact that's governed throughout the software life cycle - from conception through development to deployment and finally evolution, then to adaptation, assimilation, replacement, or abandonment. Similarly, the architect, either as an individual, a role, or a team, lovingly crafts, grows, and governs that architecture as it emerges from the thousands of individual design decisions of which it's composed. In this sense, an architecture-first approach appears to be a reflection of sound development practices. Now, strict agilists might counter that an architecture-first approach is undesirable because we should allow a system's architecture to emerge over time. More than just a reflection, however, a software development process that swirls around the growth of a software-intensive system's architecture has considerable material value. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • There's Nothing Like a Good Argument ...

    Page(s): 21 - 23
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (825 KB) |  | HTML iconHTML  

    Since computing pioneers Vannevar Bush and Doug Engelbart envisioned computational support for argumentation, many have pursued the exciting vision of tools for capturing and augmenting collective reasoning. Designers would be able to capture their deliberations on the fly during design sessions, with intuitive visualizations assisting participatory analysis by diverse stakeholders. These traces would later help recover design rationale. When managing requirements, we can think of argument schemes as reusable patterns for tightening up deliberations. Project reviews are an obvious candidate, where decisions must be justified, often to be signed off, and resources committed. As meeting capture becomes a practical reality, we have the basis for requirements platforms that provide new forms of multimedia requirements and rationale traceability. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Abstraction and Variation

    Page(s): 24 - 25
    Save to Project icon | Request Permissions | PDF file iconPDF (287 KB)  
    Freely Available from IEEE
  • Rescuing Code

    Page(s): 26 - 27
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (112 KB) |  | HTML iconHTML  

    Imagine you've experienced project heat death at least once. The term "heat death" comes from the second law of thermodynamics: entropy within a closed system increases over time without bound until the system collapses. In software, the entropy we experience most is in the design. Most of the code we add increases design entropy. Project heat death occurs when the design rots to the point where starting over is cheaper than continuing. Project heat death seems inevitable, yet when a large-scale project dies, people often stand around, surprised, asking "why us?" To do better next time, you need a sense of what problems to look for, and you need to start solving them before they spiral out of control. The author hopes this department helps in both regards. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Guest Editors' Introduction: Dynamically Typed Languages

    Page(s): 28 - 30
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (264 KB) |  | HTML iconHTML  

    The languages discussed in this special issue have a long history, which is perhaps why some have had several different names over the years. One such language is Lisp, the second-oldest programming language. For years, many somewhat dismissively described languages such as Lisp as "scripting languages." Today, we more commonly refer to them as dynamically typed languages, typified by Python and Ruby, and their impact is arguably greater than ever. This issue highlights the practical uses of such languages and shows how they're frequently a vehicle for innovation in the development sphere. This article is part of a special issue on dynamically typed languages. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Traveling Light, the Lua Way

    Page(s): 31 - 38
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (406 KB) |  | HTML iconHTML  

    Five years ago, the team at Reflexis ran into a little language from Brazil. Lua (pronounced loo-ah) changed the way they work profoundly. It lets them create hybrid solutions that combine the strengths of statically typed software with the flexibility of a dynamically typed environment. In short, with Lua, they get the best of both worlds. Lua can help you become more productive by extending your C/C++ creations with the expressive power and flexibility of a dynamically typed language. In this article, I'll share some of our experiences, a few of the lessons we've learned, and talk about changes we've made to our systems and the way we develop solutions. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A Common Medium for Programming Operations-Research Models

    Page(s): 39 - 47
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (213 KB) |  | HTML iconHTML  

    Operations research is an interdisciplinary science that develops scientific methods for modeling and solving decision-making problems. Arguably, the two most established and commonly practiced OR methodologies are mathematical programming (also called optimization) and discrete-event system simulation (called simulation). Mathematical programming describes a decision problem as decision variables and as mathematical functions of variables that capture the objective and problem constraints. For dynamic systems that are too complex to allow exact, closed-form solutions in continuous time, simulation can identify and describe events of interest and model their occurrences at discrete points in time. Python can glue together independent software environments to improve the software development cycle for sophisticated operations-research applications, which integrate different modeling methodologies. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Building Domain-Specific Languages for Model-Driven Development

    Page(s): 48 - 55
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (262 KB) |  | HTML iconHTML  

    Today, the popularity of dynamic languages such as Python and Ruby is growing beyond their use as scripting languages. In fact, Sun, Microsoft, and other companies are supporting some dynamic languages on their development platforms. Developers increasingly find that dynamic languages' features help them enhance their productivity, while common misconceptions about them, such as poor performance and reliability, are disappearing. Embedding domain-specific language in a dynamic language rather than constructing a compiler or interpreter can improve program readability and development time. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Seaside: A Flexible Environment for Building Dynamic Web Applications

    Page(s): 56 - 63
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2051 KB) |  | HTML iconHTML  

    Page-centric Web development structures an application into individual scripts, each responsible for processing a user request and generating a response. Although software developers have long considered go-to statements harmful, they are still present in today's mainstream frameworks, and they hamper the reuse of pages in different parts of the application. In this article, after briefly discussing the key challenges of modern Web application development, we present Seaside, a highly dynamic framework for developing Web applications in Smalltalk. The Seaside framework provides a uniform, pure object-oriented view for Web applications. Exploiting Smalltalk's reflective features, Seaside reintroduces procedure call abstraction in a client-server context. Furthermore, there's no need to recompile and restart Seaside application servers after each modification. Web developers debug and update applications on the fly, thus reducing development time considerably. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A Flexible Integration Framework for Semantic Web 2.0 Applications

    Page(s): 64 - 71
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (466 KB) |  | HTML iconHTML  

    The Semantic Web application framework extends Ruby on Rails to enable rapid development of integrated Semantic Web mash-ups. Web applications are mostly database driven. Developers design a database schema and then construct the application logic (which generates Web pages for user interaction) on top of the schema. These applications are centralized and rely on their own relational database, limiting the possibilities for data integration. Mash-ups (often called Web 2.0 applications) are an emerging Web development paradigm that combines functionality from different Web applications. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Point/Counterpoint

    Page(s): 72 - 75
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (433 KB)  

    Point Argument: "Dynamic Languages (in Reactive Environments) Unleash Creativity," by David Ungar. For the sake of creativity, the profession needs to concentrate more on inventing new and better dynamic languages and environments and less on improving static languages. Counterpoint Argument: "Explicitly Declared Static Types: The Missing Links," by Erik Ernst. How do we understand software? Using it is a powerful approach, but it provides examples of properties, not general truths. Some static knowledge is needed. This department is part of a special issue on dynamically typed languages. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Dynamic Detection of COTS Component Incompatibility

    Page(s): 76 - 85
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (736 KB) |  | HTML iconHTML  

    The development of COTS-based systems shifts the focus of testing and verification from single components to component integration. Independent teams and organizations develop COTS components without referring to specific systems or interaction patterns. Developing systems that reuse COTS components (even high-quality ones) therefore presents new compatibility problems. David Garlan, Robert Allen, and John Ockerbloom (1995) reported that in their experience, integrating four COTS components took 10 person-years (rather than the one planned person-year), mainly because of integration problems. According to Barry Boehm and Chris Abts (1999), three of the four main problems with reusing COTS products are absence of control over their functionality, absence of control over their evolution, and lack of design for interoperability. Our proposed technique, called behavior capture and test, detects COTS component incompatibilities by dynamically analyzing component behavior. BCT incrementally builds behavioral models of components and compares them with the behavior the components display when reused in new contexts. This lets us identify incompatibilities, unexpected interactions, untested behaviors, and dangerous side effects. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Open Source Software: All You Do Is Put It Together

    Page(s): 86 - 95
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (369 KB) |  | HTML iconHTML  

    As of 1 August 2007, SourceForge.net hosted more than 150,000 registered open source software projects, and many more projects are available on other sites. With so many OSS choices, it might seem that building a new application is only a matter of finding the appropriate projects and putting them together. We've developed the adaptable multi-interface communicator infrastructure to support rapid prototyping from OSS components. AMICO is based on existing middleware platforms for component integration, but it focuses on pragmatic aspects of OSS integration often absent from existing integration platforms. AMICO satisfies requirements based on our experiences in solving practical problems in several projects. AMICO OSS is based on a publish-subscribe infrastructure for integrating loosely coupled services. In such infrastructures, a publisher updates a shared data repository. The loosely coupled approach can be highly adaptable when using simple data structures, because new applications can use existing data in the model and add their own without breaking the infrastructure. Components communicate by exchanging events through a shared data repository consisting of named slots called variables. Components can update the variables and register for notifications about variable changes. Modules can also derive new variables by processing existing ones. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Celebrating Peopleware's 20th Anniversary

    Page(s): 96 - 100
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (71 KB) |  | HTML iconHTML  

    At the 2007 International Conference on software engineering in Minneapolis, the author had the honor of participating in a panel session celebrating the 20th anniversary of the publication of Peopleware. The panel was conceived, organized, and moderated by Steve Fraser, who deserves great credit for putting it all together and keeping the panel from degenerating into pandemonium. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Bookshelf

    Page(s): 101 - 102
    Save to Project icon | Request Permissions | PDF file iconPDF (79 KB)  
    Freely Available from IEEE

Aims & Scope

IEEE Software's mission is to build the community of leading and future software practitioners. The magazine delivers reliable, useful, leading-edge software development information to keep engineers and managers abreast of rapid technology change

Full Aims & Scope

Meet Our Editors

Editor-in-Chief
Forrest Shull
Fraunhofer Center for Experimental Software Engineering