
	Where results make sense

Topic: Immutable

In the News (Wed 15 Feb 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	The elusive origins of the immutable mobile
		Immutable mobiles, for Latour, allow centres of calculation to “act at a distance” (Latour 1987, 229), and are thus endowed with a quasi-occult power.
		Here, at last was the original source of the immutable and combinable mobile, itself the unhappy victim of a series of successive mutations through the vicissitudes of print culture, in apparent contradiction of its very nature.
		The tortuous paper-trail through the literature that we have had to follow to trace the origins of Latour’s immutable mobile certainly seems to argue against the inevitable stability of knowledge propagated via print, a stability that forms the basis of Eisenstein’s work and is the antithesis of Johns’ recent study.
	www.stanford.edu /~mgorman/immutablemobile.htm (2432 words)

	Immutable (FindBugs 1.1.3 API)
		Immutable The class to which this annotation is applied is immutable.
		Immutable objects may still have internal mutable state for purposes of performance optimization; some state variables may be lazily computed, so long as they are computed from immutable state and that callers cannot tell the difference.
		Immutable objects are inherently thread-safe; they may be passed between threads or published without synchronization.
	findbugs.sourceforge.net /api/net/jcip/annotations/Immutable.html (117 words)

	Java theory and practice: To mutate or not to mutate?
		Immutable objects have a number of properties that make working with them easier, including relaxed synchronization requirements and the freedom to share and cache object references without concern for data corruption.
		As long as immutable objects are constructed properly (which means not letting the object reference escape from the constructor), they are exempt from the requirement to synchronize access, becuase their state cannot be changed and therefore cannot have write-write or read-write conflicts.
		Immutability is what enables the Flyweight pattern, which uses sharing to facilitate using objects to represent large numbers of fine-grained objects efficiently.
	www-106.ibm.com /developerworks/java/library/j-jtp02183.html (2124 words)

	immutable concept from the Object Oriented Software Engineering knowledge base (Site not responding. Last check: 2007-10-19)
		An immutable object is an object which has a state that never changes after creation.
		An important reason for using an immutable object is that other objects can trust its content to not unexpectedly change.
		Ensure that the constructor of the immutable class is the only place where the values of instance variables are set or modified.
	www.site.uottawa.ca:4321 /oose/immutable.html (288 words)

	[No title] (Site not responding. Last check: 2007-10-19)
		Immutable metadata can also be thought of as "data-dependent" metadata, but I have chosen to call it "immutable" to emphasize that it cannot be changed directly.
		Immutable metadata is worse than useless if it is not completely tied to the state of the data itself.
		The concept of a file's size as "immutable metadata" may be difficult to get your head around, particularly since we're so used to thinking of a file's size as something that is "derived from" the data itself, rather than simply "associated with" the data like the independent metadata described earlier.
	arstechnica.com /reviews/os/metadata.ars (1661 words)

	Immutable object - Wikipedia, the free encyclopedia
		An object can be either entirely immutable or some attributes in the object may be declared immutable, for example using the const member data attribute in the C++ programming language.
		Immutability does not imply that the object as stored in the computer's memory is unwriteable.
		Rather, immutability is a compile-time construct that indicates what a programmer should do, not necessarily what he can do (for instance, by circumventing the type system or violating const correctness in C or C++).
	en.wikipedia.org /wiki/Immutable_object (1307 words)

	Using Immutable Classes (Site not responding. Last check: 2007-10-19)
		Immutable classes behave differently from reference classes both in terms of their abstract behaviour (value semantics) and in terms of their implementation.
		Unfortunately the efficiency of an immutable class appears directly tied to how smart the C compiler is; "gcc" is not very bright in this respect.
		Note that when an immutable class is passed as an argument to a function which is expecting an abstract type, the compiler boxes it i.e.
	www.gnu.org /software/sather/docs-1.2/tutorial/immutable1937.html (337 words)

	Use Immutables to represent values of abstract data types
		But ADT type immutables actually could be implemented as State Machines, because they offer services that would ordinarily be though of as something that would change their state.
		Another benefit of immutable objects is that you can pass references to them to methods without worrying that the method will change the object's state.
		In addition, if the overhead of immutability (excessive creation of short-lived objects) may at times be too inefficient, you can also define a mutable companion class that can be used when the immutable version isn't appropriate.
	www.artima.com /interfacedesign/Immutable.html (1651 words)

	Immutable Classes
		This chapter illustrates how immutable classes may be defined, and highlights the peculiarities in their usage that may trip up a beginning user.
		For experienced C programmers the difference between immutable and reference classes is similar to the difference between structs (immutable types) and pointers to structs (reference types).
		The initial value of an immutable object is defined to have all its fields set to the 'void' value and this is defined to be the 'void' value of the immutable object.
	www.gnu.org /software/sather/docs-1.2/tutorial/immutable.html (753 words)

	Java theory and practice: Urban performance legends
		The performance trade-offs between mutable and immutable objects are complicated.
		The "immutable objects are slow" myth is rooted in the more general performance principle that creating many temporary objects is bad for performance.
		Immutable objects are simpler and less error-prone to write, maintain, and use than mutable ones.
	www-106.ibm.com /developerworks/java/library/j-jtp04223.html (2359 words)

	Acronomic - View Immutable rules
		Initially rules in the 100's are immutable and rules in the 200's are mutable.
		Rules subsequently enacted or transmuted (that is, changed from immutable to mutable or vice versa) may be immutable or mutable regardless of their numbers, and rules in the Initial Set may be transmuted regardless of their numbers.
		In a conflict between a mutable and an immutable rule, the immutable rule takes precedence and the mutable rule shall be entirely void.
	www.nomic.net /deadgames/acronomic/immutable.html (1105 words)

	immutable : Java Glossary
		The only way to change the value of the number inside the object wrapper is to create a new object and point to that instead.
		Immutable objects are much better suited to be Hashtable keys.
		If you change the value of an object that is used as a hash table key without removing it and re-adding it you lose the mapping.
	mindprod.com /jgloss/immutable.html (520 words)

	Even a chimp can write code: A close look at immutable objects : Ashish Shetty's weblog (Site not responding. Last check: 2007-10-19)
		We have all heard about immutable objects but some of us do not know what that means and fewer still know how to create one.
		With immutable objects, as Mr Gosling has said, "the question of ownership, who has the right to change it, doesn't exist.
		Immutable objects aren't about thread safety, though that's a side effect.
	nerddawg.blogspot.com /2004/11/close-look-at-immutable-objects.html (761 words)

	2.1.4 Immutable Sequence Representations
		An immutable array is an array that, once initialized, is never modified.
		A lighter weight but less robust protocol for supporting immutable arrays is to use comments to indicate which arrays are immutable and to follow the discipline of never modifying arrays documented as immutable.
		The array implementation of immutable sequences is a good choice when new sequences are generally built from scratch rather than constructed by applying operations to existing sequences.
	www.cs.rice.edu /~cork/teachjava/2001/revised-notes/rev/node72.html (679 words)

	Mutable/Immutable Patterns
		The false immutable pattern, inverted or not, is seldom a good choice other than for small confined object hierarchies that you have utter and complete control over.
		The immutable class should be written as the a True Immutable, as explained earlier.
		We can't extend the immutable class since it is, and should be, final.
	www.javalobby.org /articles/immutable/index.jsp (2768 words)

	Thomas J Du Plessis's Weblog : Weblog
		An immutable object is an object whose state cannot change or be changed after it has been created.
		Of course, it is possible to do all sorts of nastiness even to immutable objects using reflection, but when one adheres to the interface instead of mucking with the bits immutable objects do not change after they have been created.
		One major advantage to immutable objects is that they can generally be shared, resulting in better performance and less memory use.
	jroller.com /page/tomdupl?entry=what_is_an_immutable_object (565 words)

	All about Linux: Make your files immutable which even root can't delete (Site not responding. Last check: 2007-10-19)
		This command is used by system administrators to restrict the users from changing a file in a particular way or even the administrator can by mistake delete a critical file because of a mis-typed command.
		immutable isn't the only flag you can use, you can set append only, for instance on a log file so that if the service doing the logging gets compromised it can't erase log entries.
		I would also set the immutable tag on the script as well so a user can't modify it unless they're in single user mode.
	linuxhelp.blogspot.com /2005/11/make-your-files-immutable-which-even.html (1522 words)

	Immutable Laws (Site not responding. Last check: 2007-10-19)
		Until such time as they are legally transmuted, Laws 1-499 are immutable, Laws 501-999 are mutable and are laws which regulate citizens and the law.
		Mutable laws that are inconsistent in some way with some immutable law (except by proposing to transmute it) are wholly void and without effect.
		Common Law which is inconsistent in some way with any other law shall only be applied to non-citizen players.Changes that transmute the category of a law will be effective only if they explicitly state their transmuting effect.
	www.shattered.org /laws/immutable.htm (609 words)

	[No title]
		Often when immutability is mentioned it isn't defined, or when it is defined there are no details of how to ensure immutability or the consequences.
		It turns out that Immutable Objects, that is objects that you cannot change the contents after they have been set, are a very handy tool when used in the right place.
		The last requirement which many people fall victim too, is to build your immutable class from primitive types or immutable fields, otherwise you have to protect mutable fields from manipulation.
	www.javaranch.com /newsletter/Apr2003/immutable.htm (1187 words)

	jaybaz [MS] WebLog : Thoughts on Immutable Types
		This is simple since the rule on C would ensure that jt was an immutable type, which means that none of its methods could affect it.
		Limiting immutability to a type instead of an instance(as const does) is a bit easier to deal with without the BCL however.
		A guarentee that a struct is immutable means that struct is immutable, it doesn't mean that other code can't change it becuase the Immutable flag says no, but because there is no way to do it.
	blogs.msdn.com /jaybaz_ms/archive/2004/06/10/152748.aspx (1390 words)

	Practical Java Praxis 65: Use Inheritance or Delegation to Define Immutable Classes > Practical Java Praxis 65: Use ... (Site not responding. Last check: 2007-10-19)
		Because the immutable interface exposes only the nonmutating methods of the underlying class, access to the object through the interface type preserves immutability.
		The object remains immutable for the duration of this method.
		This implementation ensures that the immutability constraints cannot be breached by a simple cast.
	www.informit.com /articles/article.asp?p=20522 (1043 words)

	Mutable or immutable? - Java World
		Immutability in a "weak" sense (for lack of a better term) means creating a temporary read-only view of otherwise modifiable data.
		Immutability in a "strong" sense means locking down a piece of data in perpetuity, such as creating an immutable object instance that cannot be changed by any code.
		This weak immutability pattern is a bit like const-correctness in C++, where an object's "const-ness" is enforced by the compiler and can be cast away with an explicit directive.
	www.javaworld.com /javaworld/javaqa/2002-12/01-qa-1206-immutable.html (629 words)

	Java Practices: Immutable objects
		Immutable objects are simply objects whose state (the object's data) does not change after construction.
		In this case, the state of this mutable field * is to be changed only by this class.
		tag, for example, to document a class as being immutable.
	www.javapractices.com /Topic29.cjp (464 words)

	Unique Patient Identifier based on Personal Immutable Properties.htm
		The three values are 1) a seven-digit date of birth field, 2) a six-digit place of birth code, 3) a five-digit sequence code (to identify the individual born on the same date in the same geographic area) and 4) a single-check digit.
		The model consists of 1) a seven-digit date of birth field, 2) a six-digit place of birth code, 3) a five-digit sequence code (to identify the individual born on the same date in the same geographic area) and 4) a single digit check-digit.
		The Unique Patient Identifier based on Personal Immutable Characteristics in its current form does not meet three of the five operational characteristics and the fourth is not fully addressed.
	www.ncvhs.hhs.gov /app7-5.htm (3841 words)

	jGuru: Regarding Ant's (Needlessly?) Immutable Properties
		That was a design decision made by the original Ant developers and a good one for the overall design of Ant.
		Hi, the immutable properties are no problem for me, using ant for 4 years now, i'm used to it.
		IMO it's good that properties are immutable by default.
	www.jguru.com /forums/view.jsp?EID=1323123 (572 words)

	Mutable/Immutable Patterns - By Mikael ... (Site not responding. Last check: 2007-10-19)
		We did consider another mutability pattern which was to have the immutable class non-final, but have all of its methods and fields final.
		The immutable class could be used as the property of the mutable class.
		An intermediate way would be to cache the Immutable version of the mutable object and invalidate that cached immuatable object (setting it to null) every time the object is changed.
	www.javalobby.org /java/forums/m91822683.html (1512 words)

	Overview of the collections Package (Site not responding. Last check: 2007-10-19)
		Immutable versions of collections are those that GUARANTEE not to support mutations.
		However, when you are using a received Immutable Collection as the basis for a very extensive set of update operations (none of which should be applied to the original), it is sometimes more efficient to build an UpdatableCollection, add all of the elements of the received ImmutableCollection to it, and then work off that.
		Even though they are immutable, Immutable Collections still support constructive operations that create new collections differing from their arguments only in that they add, remove, or replace a given element.
	gee.cs.oswego.edu /dl/classes/collections/index.html (4330 words)

	SRFI 65: define-immutable: A Syntax to Define Identifiers With Immutable Values
		To maximize the number of ways that immutable definitions can refer to each other, the definition's expression is evaluated lazily: it isn't evaluated unless and until the identifier itself is used in an expression.
		Immutable definitions may reference other immutable definitions within the same syntactic scope, and in any order:
		However, it is an error for an identifier to have an immutable definition when another definition of that same identifier exists in the same syntactic scope:
	srfi.schemers.org /srfi-65/srfi-65.html (1522 words)

	Amazon.ca: The 22 Immutable Laws of Marketing: Exposed and Explained by the World's Two: Books: Al Ries,Jack Trout (Site not responding. Last check: 2007-10-19)
		The 22 Immutable Laws of Marketing is an excellent refresher course to overall marketing principles in the form of bite-size sections.
		If calling any business rule-of-thumb a "law" is a recipe for disaster, claiming it is "immutable" is the proverbial fuse.
		At this point, however, applying immutable laws to the problem seems as difficult as correctly guessing the perfect conclusion to a "Choose Your Own Adventure" novel.
	www.amazon.ca /22-Immutable-Laws-Marketing-Explained/dp/0887306667 (2286 words)

	Book Review: The 11 Immutable Laws of Internet Branding, by Al Ries and Laura Ries
		This is the flip side of "immutable" law #3 that is unconvincing.
		The 11 Immutable Laws of Internet Branding is surely provocative, and I know I'll be mentally testing its theories for months in the future.
		But I come away with the feeling that the authors aren't really immersed in the e-business world, that they are seeing the Internet through an older set of glasses.
	www.wilsonweb.com /reviews/11-laws.htm (940 words)

Try your search on: Qwika (all wikis)