• Corpus ID: 9571812

Out of the Tar Pit

@inproceedings{Moseley2006OutOT,
  title={Out of the Tar Pit},
  author={Ben Moseley and Peter Marks},
  year={2006}
}
Complexity is the single major diculty in the successful development of large-scale software systems. Following Brooks we distinguish accidental from essential diculty, but disagree with his premise that most complexity remaining in contemporary systems is essential. We identify common causes of complexity and discuss general approaches which can be taken to eliminate them where they are accidental in nature. To make things more concrete we then give an outline for a potential complexity… 

Figures and Tables from this paper

Rethinking javascript loops as combinators

Using inductive loop combinators, performance can be improved without sacrificing expressiveness, and the resulting code is more modular and easier to maintain.

Functional and Imperative Object-Oriented Programming in Theory and Practice

Functional programming (FP) has progressively become more prevalent and techniques from the FP paradigm has been implemented in many different Imperative object-oriented programming (OOP) languages.

A history of Clojure

  • R. Hickey
  • Computer Science
    Proc. ACM Program. Lang.
  • 2020
The motivation behind the initial development of Clojure and the rationale for various design decisions and language constructs are recounted, and its evolution subsequent to release and adoption is covered.

Accelerating information experts through compiler design

The Co-dfns compiler project aims to reduce the overheads involved in creating high-performance code in APL, and focuses on integrating with the APL environment and compiles a familiar subset of the language, delivering significant performance and platform independence to information experts without requiring code rewrites and conversion into other languages.

Programming Languages For Interactive Computing

  • R. Perera
  • Computer Science
    Electron. Notes Theor. Comput. Sci.
  • 2008

Validation DSL for client-server applications

Why the DSL is a good fit for a validation rule engine, existing techniques used in this area are described, and the related issues of accidental complexity, security, and user experience are comprehensively addressed.

The Functional Paradigm in Embedded Real-Time Systems : A study in the problems and opportunities the functional programming paradigm entails to embedded real-time systems

This thesis explores the possibility of the functional programming paradigm in the domain of hard embedded real-time systems and finds that one can only use the functional paradigm if one has an over dimensioned system when it came to hardware, mainly when it comes to memory size and CPU power.

Concurrent Programming for Scalable Web Architectures

This work provides a survey of competing concurrency approaches and point to their adequate usages in scalable web architectures, focusing onerent stages of scalable web architecture.

Visual Enhancements for Code Examples to Support the Knowledge Exchange Between Programmers

The aim of this work is to develop visual enhancements that support programmers in the knowledge exchange with code examples that allow programmers to see the execution and simultaneously inspect the state in order to gain a better understanding of how the underlying system of the code example works.

Three Devils of Systems Engineering

Systems engineering is the engineering discipline for building, extending, and maintaining information technology systems. During the system engineering process, the developers encounter the three

References

SHOWING 1-10 OF 33 REFERENCES

No Silver Bullet Essence and Accidents of Software Engineering

This article shall try to show why there is no single development, in either technology or management technique, that by itself promises even one order-of-magnitude improvement in productivity, in reliability, in simplicity.

The Craft of Prolog

The emphasis in "The Craft of Prolog" is on using Prolog effectively, and presents a loose collection of topics that build on and elaborate concepts learning in a first course.

The humble programmer

As a result of a long sequence of coincidences I entered the programming profession officially on the first spring morning of 1952, and as far as I have been able to trace, I was the first Dutchman

Monads for functional programming

Three case studies are looked at in detail: how monads ease the modication of a simple evaluator;How monads act as the basis of a datatype of arrays subject to in-place update; and how monad can be used to build parsers.

Specifications are not (necessarily) executable

This paper presents a number of arguments against the idea that specifications might be executed, and warns of the dangers of limiting specification languages to the point where all of their constructs can be executed.

The Relational Model for Database Management, Version 2

This book describes all the features of the relational model that I now perceive as important for database users, and therefore for DBMS vendors, and contains 30 chapters and two appendixes.

Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs

A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules; these systems have semantics loosely coupled to states—only one state transition occurs per major computation.

Type inference in a database programming language

We extend an ML-like implicit type system to include a number of structures and operations that are common in database programming including sets, labeled records, joins and projections. We then show

A Simple and Unifying Approach to Subjective Objects

Applying a perspective-receiver symmetry principle in designing the subjectivity semantics of an object-oriented language results in a semantically uncluttered language with a surprisingly wide range of utility.

Equal rights for functional objects or, the more things change, the more they are the same

It is argued that intensional object identity in object-oriented programming languages and databases is best defined operationally by side-effect semantics, and this model of object identity provides cleaner semantics for the value-transmission operations and built-in primitive equality predicate of a programming language.