
	Where results make sense

Topic: Accidental complexity

Related Topics

Abstraction inversion

God object

Lava flow (programming)

Gas factory

Accumulate and fire

Interface bloat

Big ball of mud

Design by committee

Voodoo programming

Black magic (programming)

Deep magic

Continuous obsolescence

Magic (disambiguation)

VLSI

CORBA

In the News (Sun 27 May 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	php-deluxe.net - description Accidental complexity
		Accidental complexity is an avoidable problem of complexity in computer programs or their development process (computer programming).
		While essential complexity is inherent and unavoidable, accidental complexity may be caused by misunderstanding of problems, ineffective planning, or low priority placed on a project.
		It is also very common to see accidental complexity occur because the programmers and architects seek elegant solutions which frequently become unnecessarily difficult to implement and maintain.
	www.php-deluxe.net /encyclopedia,index.page,Accidental-complexity.htm (123 words)

	Accidental complexity - Wikipedia, the free encyclopedia
		Accidental complexity is an avoidable problem of complexity in computer programs or their development process (computer programming).
		While essential complexity is inherent and unavoidable, accidental complexity may be caused by misunderstanding of problems, ineffective planning, or low priority placed on a project.
		Accidental complexity is an example of an anti-pattern.
	en.wikipedia.org /wiki/Accidental_complexity (131 words)

	Accidental complexity - Definition, explanation
		Accidental complexity is a problem of complexity in computer programs or its development process (computer programming), that can be avoided, as opposed to Essential complexity.
		While some complexities are inherent, others are due to misunderstanding of problems, ineffective planning and unimportance of the project.
		Accidental complexity is an example of an anti-pattern.
	www.calsky.com /lexikon/en/txt/a/ac/accidental_complexity.php (132 words)

	Mistaeks I Hav Made: Metaphor, Complexity and Postmodern Programming
		I now think that's wrong; accidental complexity is the essential complexity of programming itself, of writing programs that must fit into an existing context of people, organisations, their needs and wants and the legacy of their history.
		I think trying to get rid of accidental complexity is like harking back to a classical golden age that never really existed.
		The attempt to create a single conceptual universe to rid the world of accidental complexity is doomed to failure.
	nat.truemesh.com /archives/000570.html (500 words)

	Hacknot - The Top 10 Elements of Good Software Design
		The essential complexity of a solution is that which is an unavoidable ramification of the complexity of the problem being solved.
		The accidental complexity of a solution is the additional complexity (beyond the essential complexity) that a solution exhibits by virtue of a particular design's approach to solving the problem.
		Accidental complexity is often the result of the intellectual conceit of the designer, looking to show off their design "chops".
	www.hacknot.info /hacknot/action/showEntry?eid=54 (1543 words)

	JOT: Journal of Object Technology - Complexity, its in the mind of the beholder, John D. McGregor
		What is complex to her is not complex to me because I understand the structure.
		Accidental complexity is the result of poor attempts to solve the problem and may be equivalent to what some are calling complication.
		Structural complexity is partially described by Boydston, “Complexity of programming increases as the lines of code per module and the number of modules to interface increase.” [Boydston 84] These definitions point out two very different perspectives on complexity.
	www.jot.fm /issues/issue_2006_01/column3 (2216 words)

	No Silver Bullet: (Site not responding. Last check: 2007-09-30)
		Much of the complexity that he must master is arbitrary complexity, forced without rhyme or reason by the many human institutions and systems to which his interfaces must conform.
		Once those accidents have been removed, the remaining ones will be smaller, and the payoff from their removal will surely be less.
		Therefore, one of the most promising of the current technological efforts, and one that attacks the essence, not the accidents, of the software problem, is the development of approaches and tools for rapid prototyping of systems as prototyping is part of the iterative specification of requirements.
	www-inst.eecs.berkeley.edu /~maratb/readings/NoSilverBullet.html (7021 words)

	Speaking of Complexity
		Complex software is harder to think about, harder to test, harder to debug, and harder to maintain — and above all, harder to learn and use.
		Complexity creates places for bugs to nest, from which they will emerge to trouble the world through the entire lifetime of their software.
		The distinction between accidental and optional complexity means that the categories we're discussing here are not the same as essence and accident in Fred Brooks's essay No Silver Bullet [Brooks], but they have common ancestry in philosophy.
	www.butte.cc.ca.us /~jerryg/art_of_unix/ch13s01.html (2227 words)

	Introduction (Site not responding. Last check: 2007-09-30)
		Some complexities are accidental, they are not an essential or inherent aspect of the task.
		Accidental properties are those that occur by chance or a consequence of implementation.
		One of the reasons it's important to recognize essential and accidental complexities is so you don't underestimate the difficulty of managing essential complexities.
	www.bit.umkc.edu /burris/pl/introduction (4752 words)

	Speaking of Complexity
		In Chapter 4 we saw that accidental interface complexity often comes from non-orthogonality in the interface design — that is, failing to carefully factor the interface operations so that each does exactly one thing.
		Accidental code complexity (making code more complicated than it needs to be to get the job done) often results from premature optimization.
		Sources of optional complexity are the most difficult to make useful generalizations about, because they so often depend on delicate judgments about which features it is worth paying the complexity cost for.
	catb.org /~esr/writings/taoup/html/ch13s01.html (2705 words)

	No Silver Bullet Essence and Accidents of Software Engineering
		Fashioning complex conceptual constructs is the essence; accidental tasks arise in representing the constructs in language.
		Much of the complexity that he must master is arbitrary complexity, forced without rhyme or reason by the many human institutions and systems to which his interfaces must conform.
		Therefore, one of the most promising of the current technological efforts, and one that attacks the essence, not the accidents, of the software problem, is the development of approaches and tools for rapid prototyping of systems as prototyping is part of the iterative specification of requirements.
	www.cis.gsu.edu /~mmoore/CIS3300/handouts/BrooksNoSilverBullet.html (6008 words)

	Lessons Learned Building OO Telecommunication Software
		Chief among these is detecting and recovering from network and host failures, minimizing the impact of communication latency, and determining an optimal partitioning of service components and workload onto processing elements throughout a network.
		Accidental complexity stems from limitations with tools and techniques used to develop distributed software.
		A common source of accidental complexity is the widespread use of algorithmic decomposition [Booch:93] (also known as functional design), which results in non-extensible and non-reusable software designs and implementations.
	www.cs.wustl.edu /~schmidt/CACM-lessons.html (1263 words)

	Advogato's Number: The Economics of Software Complexity
		So, coming back to economics, some complexity is necessary to deliver software that meets the needs and desires of users, but some of the complexity is needless.
		Since complexity is the major factor in cost, by raising the complexity required to implement a certain set of features, you make it much harder for your competitors.
		Even though the total complexity of the next version is large, the relative cost is quite a bit lower.
	www.advogato.org /article/44.html (2131 words)

	No Silver Bullet Essence and Accidents of Software Engineering
		Fashioning complex conceptual constructs is the essence; accidental tasks arise in representing the constructs in language.
		From the complexity comes the difficulty of communication among team members, which leads to product flaws, cost overruns, and schedule delays.
		It is, after all, just another high-level language, and the biggest payoff from such languages came from the first transition--the transition up from the accidental complexities of the machine into the more abstract statement of step-by-step solutions.
	virtualschool.edu /mon/SoftwareEngineering/BrooksNoSilverBullet.html (6137 words)

	The Mythical Man-Month
		He divided the complexity of software development into two parts: the "essence" -- the innate conceptual complexity of the product being developed -- and the "accidents" -- the low-level, clerical complexity of translating ideas into programming-language constructs, working with programming tools and so on.
		Whereas in 1975, he saw both components as being roughly equal contributors to programming complexity, by 1986, he felt that clerical complexity had been mostly overcome, and that conceptual complexity was the only real remaining problem.
		His verdict was that most of them (including object orientation and data abstraction) continued to address low-level, "accidental" complexity, which as he pointed out was already largely gone.
	www.geek-central.gen.nz /peeves/programming/mmm_comments.html (803 words)

	cjs \| Simplicity and Computing
		Accidental complexity is additional complexity that has been introduced into the problem, usually as part of the process of solving it.
		It hides the essential complexity of the task, the things you need to know to deal well with words in computer memory, and ends up confusing people more when they see what, for them, is non-intuitive behaviour.
		We need to expose the complexity that needs to be there and make it as accessable as possible, so that people can deal with it, rather than avoiding it.
	www.cynic.net /~cjs/computer/writings/simplicity.html (1420 words)

	The Right Size for an Editor (Site not responding. Last check: 2007-09-30)
		There is not much in the way of optional complexity that could be removed here, and it's hard to identify any accidental complexity at all.
		It's interface complexity, yes, but of a kind most users can and do ignore (the interface is semi-compact in the sense we developed in Chapter 4).
		The value of optional complexity depends on the objectives you choose, and the ability to share context among all the text-oriented tools related to a task is valuable.
	www.catb.org /~esr/writings/taoup/html/ch13s03.html (2891 words)

	The Fishbowl: Catching a Silver Bullet
		Accidental complexity is the complexity that derives from the environment that the problem is being solved in.
		And even the accidental complexity of a demo is usually of a totally different nature to that you’d encounter on a real project: the kind of complexity that accrues around a task that can be completed in the course of a lecture is vastly different to that which is encountered in a year-long multiple-developer project.
		Admittedly, if you MUST dig in to the generated code, the accidental complexity may be quite high, but my point is that it's not just a matter of reducing complexity.
	fishbowl.pastiche.org /2005/03/11/catching_a_silver_bullet (1628 words)

	Lessons Learned Building OO Telecommunication Software
		Accidental complexity stems from limitations with tools and techniques used to develop telecom software.
		A common source of accidental complexity is the widespread use of algorithmic decomposition, which results in non-extensible and non-reusable software designs and implementations.
		Apply simple solutions to complex problems that sound too good to be true typically are...
	www.cs.wustl.edu /~schmidt/ACE-lessons.html (1432 words)

	NONZERO
		If it weren't for the brick wall—that is, the fact that no species can have less than zero complexity—there would be just as many drunks south of the sidewalk as north of it, and the randomness of all their paths would be obvious.
		This growth in behavioral complexity spurred a response: the beetle's binary weapon.
		Given evolution's tendency to generate more and more species, to elevate complexity, and to keep inventing and reinventing technologies, the eventual combination of these foundational properties in a single species was likely all along.
	www.nonzero.org /newyorker.htm (5328 words)

	Brandt.Kurowski.net - Weblog
		There’s the “essential complexity” that’s inherent in the problem you’re trying to solve, and it’s really impossible to imagine any solution to the problem that wouldn’t be at least that complex, just because that’s what the problem involves.
		I think that actually introduces a third kind of complexity, because the dissonance between the essential and the incidental complexity makes it hard to tell which is which, for one thing, and it’s also difficult to understand one in the context of the other.
		So all that incidental complexity, plus the the dissonance from having the two things mixed together like that, has a lot to do with why many systems are so much more difficult to maintain than they were to develop in the first place.
	brandt.kurowski.net /blog/ruby (682 words)

	Pyre Blog » Blog Archive » Accidental Horizons
		Intrinsic complexity is how hard a problem really is; accidental complexity is how much harder we make it by creating inconsistent APIs, fragile configuration files, or GUIs that don’t accurately reflect the state of the world.
		Hibernate is supposed to abstract away the details of working with databases directly; as far as I’m concerned, it should also abstract away the details of debugging my interactions with the database.
		It is a purely accidental horizon, and the sooner it’s eliminated, the more productive we will all be [3].
	pyre.third-bit.com /blog/archives/000102.html (695 words)

	CS373, Fall 2002: small group discussion 2002/08/30 (Site not responding. Last check: 2007-09-30)
		Though these are promising approaches and expansions to the solutions of accidental difficulties and attacks on conceptual essence, respectively, they must be developed and implemented well, in order to have a profound impact.
		Whereas an accident is problem we encounter when trying to produce software and can be resolved with ingenuity or breakthrough in technology.
		OOP solves accidental difficulties in several ways, one of which is by creating safer reusable code.
	www.cs.utexas.edu /~almstrum/cs373/fa02/0830-essence-accidents.html (3739 words)

	raganwald: Abbreviation, Accidental Complexity, and Abstraction
		Some programs are shorter through mere abbreviation, some are shorter through hiding accidental complexity, and some are shorter by providing useful abstractions.
		We must be mindful of the distinction between abbreviation, removing accidental complexity, and introducing useful abstractions.
		Code brevity in and of itself is not desirable, well-abstracted code with a minimum of accidental complexity is desirable, and brevity follows when these goals are attained.
	weblog.raganwald.com /2007/07/abbreviation-accidental-complexity-and.html (2226 words)

	Facts about accidental complexity
		Accidental complexity is a problem of complexity in computer programs or its development process (computer programming), that can be avoided.
		Many prototypes likely happen to be too complex because programmers use those prototypes to understand the matters they face.
		Serebella: Index - Accidental Centaurs to Accounting cost
	www.supercrawler.com /Facts/accidental_complexity.html (95 words)

	Accidental Complexity
		It stems from the complex code resulting from ugly designed interfaces of system routines.
		"Pretentious complexity" would be an appropriate term in a lot of cases.
		You could think of that anthropomorphically: the complexity seems ("pretends to be") necessary, but isn't.
	c2.com /cgi/wiki?AccidentalComplexity (439 words)

	The Joel on Software Discussion Group - Don't praise accidental complexity; bury it
		Pointers are not Accidental Complexity as it is defined because pointers are a fundamental basis of computer processors.
		The accidental complexity is not buried, it is just shifted from the programmer to the user.
		Point is I simply was agreeing with the title of the thread, "Don't praise accidental complexity; bury it." Joel provided an unnecessary complex and obfuse solution when a simpler one would have suffice, i.e.
	discuss.joelonsoftware.com /default.asp?joel.3.278613 (4044 words)

	[No title]
		3.6 3 points off because there are many types of pseudo code and it's not specified how it might address essential complexity.
		3.6 3 points off because it is not made clear what part of essential complexity is reduced by documentation.
		6 5 points off because configuration management addresses accidental complexity.
	www.ics.uci.edu /~frost/past/ics121-F05/detail-assignment1.html (1385 words)

	Object-Oriented Design Heuristics (Site not responding. Last check: 2007-09-30)
		Accidental Versus Essential Complexity à la Frederick Brooks.
		Accidental Complexity In Languages That Do Not Support Multiple Inheritance.
		Accidental DAG Multiple Inheritance via Poor Implementation of Optional Containment.
	www.booksmatter.com /b020163385X.htm (300 words)

Try your search on: Qwika (all wikis)