
	Where results make sense

Topic: Fragile base class

Related Topics

stolen bases

Base chemistry

Edwards Air Force Base

base on balls

All your base are belong to us

on base percentage

SI base units

base pairs

Bagram Air Base

Ace of Base

evidence based medicine

third base

In the News (Thu 16 Feb 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	Fragile base class - Wikipedia, the free encyclopedia
		The fragile base class problem is a fundamental architectural problem of object-oriented programming systems where base classes (superclasses) are considered "fragile" because seemingly safe modifications to a base class, when inherited by the derived classes, may cause the derived classes to malfunction.
		You can't tell whether a base class change is safe simply by examining the base class's methods in isolation.
		Sometimes the fragile binary interface problem is referred to as the fragile base class problem.
	en.wikipedia.org /wiki/Fragile_base_class (127 words)

	Talk:Fragile base class - Wikipedia, the free encyclopedia
		A bit of Googling reveals that most pages define FBC to mean a language- and implementation-independent problem that occurs when a base class changes and unexpectedly affects its subclasses.
		FBC is the fault of the compiler / linker, and is nothing at all to do with the language.
		One example of FBC from the understanding i get from different books, could be adding an overload of a method to a base class, which may cause an amiguity with multiple overlad selection possibilities later in the software.
	en.wikipedia.org /wiki/Talk:Fragile_base_class (1733 words)

	CodeNotes® - Article Display
		The fragile base class problem arises when changing the functionality of a superclass results in any of its extension (sub-) classes ceasing to work correctly.
		In general, you should only use and extend classes from sources that are trustworthy enough to fully test their code before releasing it, to deprecate methods before removing them, and to inform users in documentation of any changes to code library structure.
		Give each class separate, and less responsibility in order to avoid having one class that is crucial to the functionality of all the others.
	www.codenotes.com /articles/articleAction.aspx?articleID=371 (1360 words)

	Fragile base class (Site not responding. Last check: 2007-10-21)
		The fragile base class problem is a shortcoming of certain object-oriented language compilers, in which internalchanges to an underlying class library can cause descendant libraries or programs to cease working.
		These base classes are fragilebecause a small change to one of them could cause problems for any class that inherits from it (either directly or frominheriting another class that does).
		The best solution to the fragile base class problem is to write a language that knows the problem exists, and does not let ithappen in the first place.
	therfcc.org /fragile-base-class-256015.html (923 words)

	Frequently Asked Questions about XL
		The fragile base class problem is the issue that modifications in the base class may break derived classes that use it.
		The base class is fragile because changes in it break its role as a base class.
		The weak base class problem is the issue that a class cannot be reused because it lacks necessary functionality, and said functionality cannot be added without "opening" the class, which may not be acceptable if the class is not owned (e.g.
	mozart-dev.sourceforge.net /xl_faq.html (1574 words)

	Citations: A Study of The Fragile Base Class Problem - Mikhajlov, Sekerinski (ResearchIndex) (Site not responding. Last check: 2007-10-21)
		Although tracking down bugs introduced by changing a base class is difficult (only a superclass of the class where the error shows up has been changed) the problem is even worse with aspect languages as....
		Although tracking down bugs introduced by changing a base class is difficult, the problem is even worse with aspect languages as modifications of the base class are not visible if the code is viewed in isolation (i.e.
		Class refinement has also been studied under the name behavioral subtyping in less formal settings guaranteeing only partial correctness by America [2] and by Liskov and Wing [22] Different models for classes and objects have been proposed [1] We extend the model....
	citeseer.lcs.mit.edu /context/164208/531660 (2772 words)

	Encyclopedia: Fragile base class
		In computer science, a superclass is a class from which other classes are derived.
		In object-oriented programming, a subclass is a class that inherits some properties from its superclass.
		The fragile binary interface problem is a shortcoming of certain object-oriented language compilers, in which internal changes to an underlying class library can cause descendant libraries or programs to cease working.
	www.nationmaster.com /encyclopedia/Fragile-base-class (255 words)

	Base Class Design Changes After Deployment
		Changes to base classes often require the base class and all the code in derived classes to be changed, recompiled, and redistributed.
		Base class changes that can potentially break derived classes include overriding or changing the data type of base class members.
		In the final analysis, the fragile base class problem cannot be eliminated, but it can be minimized through careful design of class hierarchies that reduces the need for base class changes, and through thorough testing when such changes are unavoidable.
	msdn2.microsoft.com /library/s57zewcx(en-us,vs.80).aspx (466 words)

	MemoRanda
		The main points are two: that declaring variables and arguments to be of concrete class types makes changes more difficult, and that changing the internal behavior of a base class can cause problems for subclasses that relied on the internal behavior.
		Holub's "fragile base class problem" is just a specific instance of unexpected coupling between two classes (which are connected via inheritance in his example, but could be coupled by a "uses" relationship).
		If you have modified the base class so it doesn't perform the way the subclass expects, the subclass's tests should fail, alerting you to undo your change, or modify the class or its subclass.
	homepage.mac.com /keithray/blog/2004/01/02 (313 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		A solution to a Fragile-Base Class Problem It is possible to fortify at least a significant chunk of a class derivation tree, even against additions of virtual functions to a base class.
		This technique requires some discipline in building a hierarchy, but in return guarantees that only the top-most class needs to be recompiled to take into account modifications made to a base class.
		The Upshot When a base class of a class hierarchy is extended with new data members, overridden virtual methods, or even with new virtual functions, it is nevertheless possible to avoid rebuilding of the entire hierarchy.
	okmij.org /ftp/c++-digest/FBCSolution.txt (569 words)

	Fragile Base Class Problem
		The syntactic fragile base class problem, which is described in FragileBinaryInterfaceProblem, and the semantic fragile base class problem, described here.
		Actually, introducing a new method to the base class which "underrides" a formerly non-overriding function in a derived class is fairly rare; though CsharpLanguage provides the override keyword to prevent that sort of thing (and others).
		If the base class and the derived class are created by different companies, it would be really hard to make any modification that doesn't break the build.
	c2.com /cgi/wiki?FragileBaseClassProblem (659 words)

	Why extends is evil
		You can't eliminate coupling altogether because a method call from an object of one class to an object of another is a form of loose coupling.
		Base classes are considered fragile because you can modify a base class in a seemingly safe way, but this new behavior, when inherited by the derived classes, might cause the derived classes to malfunction.
		A discussion of fragile base classes would be incomplete without a mention of framework-based programming.
	www.javaworld.com /javaworld/jw-08-2003/jw-0801-toolbox.html (2598 words)

	Business Object Components
		Moreover, the term “the fragile base class problem” is made to refer to different phenomena by different authors.
		Mostly, the concept is understood as referring to problems that occur when base class implementations evolve independently of their subclasses, and this will also be the sense used here.
		class fragility caused by the flawed inheritance mechanism of today’s object-oriented approach must be addressed.
	www.jeffsutherland.com /oopsla2000/persson/persson.htm (3677 words)

	C# Frequently Asked Questions : What's the difference between `override` and `new`?
		When a virtual method is called on a reference, the actual type of the object that the reference refers to is used to decide which method implementation to use.
		When a method of a base class is overridden in a derived class, the version in the derived class is used, even if the calling code didn't "know" that the object was an instance of the derived class.
		A new version of a base class may be released which happens to introduce a method with the same name as a method in your derived class.
	blogs.msdn.com /csharpfaq/archive/2004/03/12/88453.aspx (535 words)

	Scott Collins' Journal
		You needed to derive a class because there was no other way for you to intercept the necessary calls to the base class...
		Once upon a time, the Fragile Base Class problem only meant that changes to a base class were often source compatible but not link compatible with previously compiled derived classes in some other library.
		Inversion is O(1) for bit based implementations and O(N), N the number of elements in the universe, for everybody else.
	www.scottcollins.net /blog (6840 words)

	base class robust or not?
		That is one technique (of several) for avoiding phenomena such as the "fragile base class", which basically means that changes to a base class (eg renaming a variable, or changing how you use it) result in needing to confirm that all derived classes function correctly.
		The basic philosophy is that the protected member function ensure that private data is always sensible, and you don't rely on the creators of derived classes to explicitly do that for you.
		That isn't so important in your example, but is important in larger systems where arrays of objects last for a while, and the code where they need to disappear is very much separated from the code where the objects are created.
	forums.devshed.com /t108186/s.html (650 words)

	A Study of The Fragile Base Class Problem (Site not responding. Last check: 2007-10-21)
		In this paper we study the fragile base class problem.
		We express the fragile base class problem in terms of a exibility property.
		We formulate and formally prove a exibility theorem demonstrating that the restrictions we impose on inheritance are sufcient to permit safe substitution of a base class with its revision in presence of extension classes.
	www.cas.mcmaster.ca /%7Eemil/publications/fragile (183 words)

	A Study of The Fragile Base Class Problem (Site not responding. Last check: 2007-10-21)
		System developers unaware of extensions to the system developed by its users may produce a seemingly acceptable revision of a base class which may damage its extensions.
		The fragile base class problem becomes apparent during maintenance of open object-oriented systems, but requires consideration during design.
		We formulate requirements for disciplining inheritance, and extend the renement calculus to accommodate for classes, objects, class-based inheritance, and class renement.
	www.cas.mcmaster.ca /~emil/publications/fragile (183 words)

	Otaku, Cedric's weblog: "Inheritance considered evil" considered evil
		Allen mentions the fragile base class problem as one of the reasons why you should avoid inheritance altogether.
		To illustrate, Allen uses the example of a Stack class that uses a List as its underlying implementation and he notices that calling clear() on this object will clear only the base class and not the derived one.
		But this is not the fragile base class problem.
	beust.com /weblog/archives/000004.html (1381 words)

	Categories and Fragile Base Class problem (was Objective-C vs. Java)
		Fragile Base Class Problem: When the modification to a class require other code to be recompiled.
		I can not remember if classes that use that class also need to be recompiled (been hiding from C++ for too long).
		Categories are truly the solution to the fragile base class problem in Obj-C, because it doesn't really have it, with the exception of ivars.
	www.wodeveloper.com /omniLists/webobjects/1998/msg00198.html (568 words)

	A Moment of Clarity: It's amazing what we put up with (Site not responding. Last check: 2007-10-21)
		The class bogged down in the lab section because the materials had a couple of typos in them - mostly capitalization problems.
		The materials should have been better proofread (this was the first time the class was taught) but that isn't the point of this entry.
		Class files aren't executable; they are really compile intermediate forms that can be compiled to native code (or interpreted, as was originally intended) at runtime.
	blogs.ittoolbox.com /eai/clarity/archives/006383.asp?rss=1 (960 words)

	CodeNotes® - Book Articles
		This article illustrates how it is possible to simulate multiple inheritance, allowing a single class to provide the methods, and the respective implementations, of two parent classes.
		Like classes, when interfaces are extended, they inherit all the operations of the parent class.
		RMI allows one Java Virtual Machine (the client) to interact with classes on another JVM (the server) which may be on a different computer or a different operating system.
	www.codenotes.com /books/bookArticlesAction.aspx?bookID=5&start=10 (359 words)

	[No title]
		No categories means that a class can not be amended to suit your needs (a problem suffered by more OO languages, including C++.
		In Java, you can pass around anything as an Object, but you need to know the class of that Object if you want to call a method on that instance.\ \ Java has the "fragile base class" problem, as does C++.
		There is a strict relationship between classes and the files that define them.
	www.wodeveloper.com /omniLists/webobjects/1998/rtf00000.rtf (1949 words)

	What's the Fragile Base Class (FBC) Problem? (Site not responding. Last check: 2007-10-21)
		New classes are permitted as long as they don't change the inheritance hierarchy of the existing classes.
		Re-implementing old functions is obviously not something to be done lightly, but it's not going to tickle the FBC problem.
		When thinking about the FBC problem realize that the "protected" C++ keyword really means "public." Anything that is "protected" is publicly visible.
	2f.ru /holy-wars/fbc.html (1402 words)

	Analysis of Aspect-Oriented Software
		It gives the developer more flexibility and power, it also produces aspects that are more brittle, in that they rely on internal implementation details, and not just on the available interfaces.
		Changing the base code would then require taking into account the aspect definition in the system, which would contradict that aspects would be non invasive
		Use of inheritance to reuse a base aspect’s behavior leads to anomalies similar to the fragile base class problem in OO?
	www.iit.edu /~concur/AAOS_files/slide0010.htm (139 words)

	LtU Classic Archives
		By specifying a method as open,a developer is promising that future versions of the class will make internal calls to that method in exactly the same way as the current implementation.
		The last possibility is "By declaring a method 'open,' the author of a class is promising that any changes to the class will preserve the ways in which that method is called".
		However, within a class definition, any message sends to self are dispatched statically, unless the method is marked open (in which case it is always dispatched dynamically).
	lambda-the-ultimate.org /classic/message12271.html (968 words)

	Otaku, Cedric's weblog: August 2003 Archives
		An API to declare what classes I make available and where the metadata can be found (contracts, documentation, etc...).
		It propagated by copying itself on the boot sector of floppies and all it did is wait for the third invocation and then display a message saying "Something wonderful has happened, your Amiga is alive, etc...".
		I remember finding this cool the very first time I saw it, probably because I had no idea it was based on a concept that would cause billions of dollars in losses in the coming years.
	beust.com /weblog/archives/2003_08.html (4772 words)

	VB.NET: Object-Oriented Programming Concepts (Site not responding. Last check: 2007-10-21)
		Classes define the properties and methods of an object type, but it is important to remember that a developer cannot use a class directly; instead, an object must be created from a class—it must be instantiated.
		First, in VB 6 a class was defined as a file with a.CLS extension: in VB.NET this is done in code.
		There were multiple ways to create an instance of a class in VB 6.
	www.informit.com /articles/article.asp?p=25857&seqNum=5 (645 words)

Try your search on: Qwika (all wikis)