text:
- Tutoriels
- Performance Optimization
- Optimizing garbage collection in Unity games
Optimizing garbage collection in Unity games
Vérifié avec version: 5.5
Difficulté: Intermédiaire
When our game runs, it uses memory to store data. When this data is no longer needed, the memory that stored that data is freed up so that it can be reused. Garbage is the term for memory that has been set aside to store data but is no longer in use. Garbage collection is the name of the process that makes that memory available again for reuse.
Unity uses garbage collection as part of how it manages memory. Our game may perform poorly if garbage collection happens too often or has too much work to do, which means that garbage collection is a common cause of performance problems.
In this article, we'll learn how garbage collection works, when garbage collection happens and how to use memory efficiently so that we minimize the impact of garbage collection on our game.
Diagnosing problems with garbage collection
Performance problems caused by garbage collection can manifest as low frame rates, jerky performance or intermittent freezes. However, other problems can cause similar symptoms. If our game has performance problems like this, the first thing we should do is to use Unity's Profiler window to establish whether the problems we are seeing are actually due to garbage collection.
To learn how to use the Profiler window to find the cause of your performance problems, please follow this tutorial.
A brief introduction to memory management in Unity
To understand how garbage collection works and when it happens, we must first understand how memory usage works in Unity. Firstly, we must understand that Unity uses different approaches when running its own core engine code and when running the code that we write in our scripts.
The way Unity manages memory when running its own core Unity Engine code is called manual memory management. This means that the core engine code must explicitly state how memory is used. Manual memory management does not use garbage collection and won't be covered further in this article.
The way that Unity manages memory when running our code is called automatic memory management. This means that our code doesn't need to explicitly tell Unity how to manage memory in a detailed way. Unity takes care of this for us.
At its most basic level, automatic memory management in Unity works like this:
Unity has access to two pools of memory: the stack and the heap (also known as the managed heap. The stack is used for short term storage of small pieces of data, and the heap is used for longer term storage and larger pieces of data.
When a variable is created, Unity requests a block of memory from either the stack or the heap.
As long as the variable is in scope (still accessible by our code), the memory assigned to it remains in use. We say that this memory has been allocated. We describe a variable held in stack memory as an object on the stack and a variable held in heap memory as an object on the heap.
When the variable goes out of scope, the memory is no longer needed and can be returned to the pool that it came from. When memory is returned to its pool, we say that the memory has been deallocated. Memory from the stack is deallocated as soon as the variable it refers to goes out of scope. Memory from the heap, however, is not deallocated at this point and remains in an allocated state even though the variable it refers to is out of scope.
The garbage collector identifies and deallocates unused heap memory. The garbage collector is run periodically to clean up the heap.
Now that we understand the flow of events, let's take a closer look at how stack allocations and deallocations differ from heap allocations and deallocations.
What happens during stack allocation and deallocation?
Stack allocations and deallocations are quick and simple. This is because the stack is only used to store small data for short amounts of time. Allocations and deallocations always happen in a predictable order and are of a predictable size.
The stack works like a stack data type: it is a simple collection of elements, in this case blocks of memory, where elements can only be added and removed in a strict order. This simplicity and strictness is what makes it so quick: when a variable is stored on the stack, memory for it is simply allocated from the "end" of the stack. When a stack variable goes out of scope, the memory used to store that variable is immediately returned to the stack for reuse.
What happens during a heap allocation?
A heap allocation is much more complex than a stack allocation. This is because the heap can be used to store both long term and short term data, and data of many different types and sizes. Allocations and deallocations don't always happen in a predictable order and may require very different sized blocks of memory.
When a heap variable is created, the following steps take place:
First, Unity must check if there is enough free memory in the heap. If there is enough free memory in the heap, the memory for the variable is allocated.
If there is not enough free memory in the heap, Unity triggers the garbage collector in an attempt to free up unused heap memory. This can be a slow operation. If there is now enough free memory in the heap, the memory for the variable is allocated.
If there isn't enough free memory in the heap after garbage collection, Unity increases the amount of memory in the heap. This can be a slow operation. The memory for the variable is then allocated.
Heap allocations can be slow, especially if the garbage collector must run and the heap must be expanded.
What happens during garbage collection?
When a heap variable goes out of scope, the memory used to store it is not immediately deallocated. Unused heap memory is only deallocated when the garbage collector runs.
Every time the garbage collector runs, the following steps occur:
The garbage collector examines every object on the heap.
The garbage collector searches all current object references to determine if the objects on the heap are still in scope.
Any object which is no longer in scope is flagged for deletion.
Flagged objects are deleted and the memory that was allocated to them is returned to the heap.
Garbage collection can be an expensive operation. The more objects on the heap, the more work it must do and the more object references in our code, the more work it must do.
When does garbage collection happen?
Three things can cause the garbage collector to run:
The garbage collector runs whenever a heap allocation is requested that cannot be fulfilled using free memory from the heap.
The garbage collector runs automatically from time to time (although the frequency varies by platform).
The garbage collector can be forced to run manually.
Garbage collection can be a frequent operation. The garbage collector is triggered whenever a heap allocation cannot be fulfilled from available heap memory, which means that frequent heap allocations and deallocations can lead to frequent garbage collection.
Problems with garbage collection
Now that we understand the role that garbage collection plays in memory management in Unity, we can consider the types of problems that might occur.
The most obvious problem is that the garbage collector can take a considerable amount of time to run. If the garbage collector has a lot of objects on the heap and/or a lot of object references to examine, the process of examining all of these objects can be slow. This can cause our game to stutter or run slowly.
Another problem is that the garbage collector may run at inconvenient times. If the CPU is already working hard in a performance-critical part of our game, even a small amount of additional overhead from garbage collection can cause our frame rate to drop and performance to noticeably change.
Another problem that is less obvious is heap fragmentation. When memory is allocated from the heap it is taken from the free space in blocks of different sizes depending on the size of data that must be stored. When these blocks of memory are returned to the heap, the heap can get split up into lots of small free blocks separated by allocated blocks. This means that although the total amount of free memory may be high, we are unable to allocate large blocks of memory without running the garbage collector and/or expanding the heap because none of the existing blocks are large enough.
There are two consequences to a fragmented heap. The first is that our game's memory usage will be higher than it needs to be and the second is that the garbage collector will run more frequently. For a more detailed discussion of heap fragmenation, see this Unity best practice guide on performance.
Finding heap allocations
If we know that garbage collection is causing problems in our game, we need to know is which parts of our code are generating garbage. Garbage is generated when heap variables go out of scope, so first we need to know what causes a variable to be allocated on the heap.
What is allocated on the stack and the heap?
In Unity, value-typed local variables are allocated on the stack and everything else is allocated on the heap. If you're unsure of the difference between value and reference types in Unity, see this tutorial.
The following code is an example of a stack allocation, as the variable localInt is both local and value-typed. The memory allocated for this variable will be deallocated from the stack immediately after this function has finished running.
void ExampleFunction() { int localInt = 5; }
The following code is an example of a heap allocation, as the variable localList is local but reference-typed. The memory allocated for this variable will be deallocated when the garbage collector runs.
void ExampleFunction() { List localList = new List(); }
Using the Profiler window to find heap allocations
We can see where our code is creating heap allocations with the Profiler window.
With the CPU usage profiler selected, we can select any frame to see CPU usage data about that frame in the bottom part of the Profiler window. One of the columns of data is called GC alloc. This column shows heap allocations that are being made in that frame. If we select the column header we can sort the data by this statistic, making it easy to see which functions in our game are causing the most heap allocations. Once we know which function causes the heap allocations, we can examine that function.
Once we know what code within the function is causing garbage to be generated, we can decide how to solve this problem and minimize the amount of garbage generated.
Reducing the impact of garbage collection
Broadly speaking, we can reduce the impact of garbage collection on our game in three ways:
We can reduce the time that the garbage collector takes to run.
We can reduce the frequency with which the garbage collector runs.
We can deliberately trigger the garbage collector so that it runs at times that are not performance-critical, for example during a loading screen.
With that in mind, there are three strategies that will help us here:
We can organise our game so we have fewer heap allocations and fewer object references. Fewer objects on the heap and fewer references to examine means that when garbage collection is triggered, it takes less time to run.
We can reduce the frequency of heap allocations and deallocations, particularly at performance-critical times. Fewer allocations and deallocations means fewer occasions that trigger garbage collection. This also reduces risk of heap fragmentation.
We can attempt to time garbage collection and heap expansion so that they happen at predictable and convenient times. This is a more difficult and less reliable approach, but when used as part of an overall memory management strategy can reduce the impact of garbage collection.
Reducing the amount of garbage created
Let's examine a few techniques that will help us to reduce the amount of garbage generated by our code.
If our code repeatedly calls functions that lead to heap allocations and then discards the results, this creates unnecessary garbage. Instead, we should store references to these objects and reuse them. This technique is known as caching.
In the following example, the code causes a heap allocation each time it is called. This is because a new array is created.
void OnTriggerEnter(Collider other) { Renderer[] allRenderers = FindObjectsOfType<Renderer>(); ExampleFunction(allRenderers); }
The following code causes only one heap allocation, as the array is created and populated once and then cached. The cached array can be reused again and again without generating more garbage.
private Renderer[] allRenderers; void Start() { allRenderers = FindObjectsOfType<Renderer>(); } void OnTriggerEnter(Collider other) { ExampleFunction(allRenderers); }
Don't allocate in functions that are called frequently
If we have to allocate heap memory in a MonoBehaviour, the worst place we can do it is in functions that run frequently. Update() and LateUpdate(), for example, are called once per frame, so if our code is generating garbage here it will quickly add up. We should consider caching references to objects in Start() or Awake() where possible, or ensuring that code that causes allocations only runs when it needs to.
Let's look at a very simple example of moving code so that it only runs when things change. In the following code, a function that causes an allocation is called every time Update() is called, creating garbage frequently:
void Update() { ExampleGarbageGeneratingFunction(transform.position.x); }
With a simple change, we now ensure that the allocating function is called only when the value of transform.position.x has changed. We are now only making heap allocations when necessary rather than in every single frame.
private float previousTransformPositionX; void Update() { float transformPositionX = transform.position.x; if (transformPositionX != previousTransformPositionX) { ExampleGarbageGeneratingFunction(transformPositionX); previousTransformPositionX = transformPositionX; } }
Another technique for reducing garbage generated in Update() is to use a timer. This is suitable for when we have code that generates garbage that must run regularly, but not necessarily every frame.
In the following example code, the function that generates garbage runs once per frame:
void Update() { ExampleGarbageGeneratingFunction(); }
In the following code, we use a timer to ensure that the function that generates garbage runs once per second.
private float timeSinceLastCalled; private float delay = 1f; void Update() { timeSinceLastCalled += Time.deltaTime; if (timeSinceLastCalled > delay) { ExampleGarbageGeneratingFunction(); timeSinceLastCalled = 0f; } }
Small changes like this, when made to code that runs frequently, can greatly reduce the amount of garbage generated.
Clearing collections
Creating new collections causes allocations on the heap. If we find that we're creating new collections more than once in our code, we should cache the reference to the collection and use Clear() to empty its contents instead of calling new repeatedly.
In the following example, a new heap allocation occurs every time *new *is used.
void Update() { List myList = new List(); PopulateList(myList); }
In the following example, an allocation occurs only when the collection is created or when the collection must be resized behind the scenes. This greatly reduces the amount of garbage generated.
private List myList = new List(); void Update() { myList.Clear(); PopulateList(myList); }
Object pooling
Even if we reduce allocations within our scripts, we may still have garbage collection problems if we create and destroy a lot of objects at runtime. Object pooling is a technique that can reduce allocations and deallocations by reusing objects rather than repeatedly creating and destroying them. Object pooling is used widely in games and is most suitable for situations where we frequently spawn and destroy similar objects; for example, when shooting bullets from a gun.
A full guide to object pooling is beyond the scope of this article, but it is a really useful technique and one worth learning. This tutorial on object pooling on the Unity Learn site is a great guide to implementing an object pooling system in Unity.
Common causes of unnecessary heap allocations
We understand that local, value-typed variables are allocated on the stack and that everything else is allocated on the heap. However, there are lots of situations where heap allocations may take us by surprise. Let's take a look at a few common causes of unnecessary heap allocations and consider how best to reduce these.
In C#, strings are reference types not value types, even though they seem to hold the "value" of a string. This means that creating and discarding strings creates garbage. As strings are commonly used in a lot of code, this garbage can really add up.
Strings in C# are also immutable, which means that their value can't be changed after they are first created. Every time we manipulate a string (for example, by using the + operator to concatenate two strings), Unity creates a new string with the updated value and discards the old string. This creates garbage.
We can follow a few simple rules to keep garbage from strings to a minimum. Let's consider these rules, then look at an example of how to apply them.
We should cut down on unnecessary string creation. If we are using the same string value more than once, we should create the string once and cache the value.
We should cut down on unnecessary string manipulations. For example, if we have a Text component that is updated frequently and contains a concatenated string we could consider separating it into two Text components.
If we have to build strings at runtime, we should use the StringBuilder class. The StringBuilder class is designed for building strings without allocations and will save on the amount of garbage we produce when concatenating complex strings.
We should remove calls to Debug.Log() as soon as they are no longer needed for debugging purposes. Calls to Debug.Log() still execute in all builds of our game, even if they do not output to anything. A call to Debug.Log() creates and disposes of at least one string, so if our game contains many of these calls, the garbage can add up.
Let's examine an example of code that generates unnecessary garbage through inefficient use of strings. In the following code, we create a string for a score display in Update() by combining the string "TIME:" with the value of the float timer. This creates unnecessary garbage.
public Text timerText; private float timer; void Update() { timer += Time.deltaTime; timerText.text = "TIME:" + timer.ToString(); }
In the following example, we have improved things considerably. We put the word "TIME:" in a separate Text component, and set its value in Start(). This means that in Update(), we no longer have to combine strings. This reduces the amount of garbage generated considerably.
public Text timerHeaderText; public Text timerValueText; private float timer; void Start() { timerHeaderText.text = "TIME:"; } void Update() { timerValueText.text = timer.toString(); }
Unity function calls
It's important to be aware that whenever we call code that we didn't write ourselves, whether that's in Unity itself or in a plugin, we could be generating garbage. Some Unity function calls create heap allocations, and so should be used with care to avoid generating unnecessary garbage.
There is no list of functions that we should avoid. Every function can be useful in some situations and less useful in others. As ever, it's best to profile our game carefully, identify where garbage is being created and think carefully about how to handle it. In some cases, it may be wise to cache the results of the function; in other cases, it may be wise to call the function less frequently; in other cases, it may be best to refactor our code to use a different function. Having said that, let's look at a couple of common examples of Unity functions that cause heap allocations and consider how best to handle them.
Every time we access a Unity function that returns an array, a new array is created and passed to us as the return value. This behaviour isn't always obvious or expected, especially when the function is an accessor (for example, Mesh.normals).
In the following code, a new array is created for each iteration of the loop.
void ExampleFunction() { for (int i = 0; i < myMesh.normals.Length; i++) { Vector3 normal = myMesh.normals[i]; } }
It's easy to reduce allocations in cases like this: we can simply cache a reference to the array. When we do this, only one array is created and the amount of garbage created is reduced accordingly.
The following code demonstrates this. In this case, we call Mesh.normals before the loop runs and cache the reference so that only one array is created.
void ExampleFunction() { Vector3[] meshNormals = myMesh.normals; for (int i = 0; i < meshNormals.Length; i++) { Vector3 normal = meshNormals[i]; } }
Another unexpected cause of heap allocations can be found in the functions GameObject.name or GameObject.tag. Both of these are accessors that return new strings, which means that calling these functions will generate garbage. Caching the value may be useful, but in this case there is a related Unity function that we can use instead. To check a GameObject's tag against a value without generating garbage, we can use GameObject.CompareTag().
In the following example code, garbage is created by the call to GameObject.tag:
private string playerTag = "Player"; void OnTriggerEnter(Collider other) { bool isPlayer = other.gameObject.tag == playerTag; }
If we use GameObject.CompareTag(), this function no longer generates any garbage:
private string playerTag = "Player"; void OnTriggerEnter(Collider other) { bool isPlayer = other.gameObject.CompareTag(playerTag); }
GameObject.CompareTag isn't unique; many Unity function calls have alternative versions that cause no heap allocations. For example, we could use Input.GetTouch() and Input.touchCount in place of Input.touches, or Physics.SphereCastNonAlloc() in place of Physics.SphereCastAll().
Boxing is the term for what happens when a value-typed variable is used in place of a reference-typed variable. Boxing usually occurs when we pass value-typed variables, such as ints or floats, to a function with object parameters such as Object.Equals().
For example, the function String.Format() takes a string and an object parameter. When we pass it a string and an int, the int must be boxed. Therefore the following code contains an example of boxing:
void ExampleFunction() { int cost = 5; string displayString = String.Format("Price: {0} gold", cost); }
Boxing creates garbage because of what happens behind the scenes. When a value-typed variable is boxed, Unity creates a temporary System.Object on the heap to wrap the value-typed variable. A System.Object is a reference-typed variable, so when this temporary object is disposed of this creates garbage.
Boxing is an extremely common cause of unnecessary heap allocations. Even if we don't box variables directly in our code, we may be using plugins that cause boxing or it may be happening behind the scenes of other functions. It's best practice to avoid boxing wherever possible and to remove any function calls that lead to boxing.
Calling StartCoroutine() creates a small amount of garbage, because of the classes that Unity must create instances of to manage the coroutine. With that in mind, calls to StartCoroutine() should be limited while our game is interactive and performance is a concern. To reduce garbage created in this way, any coroutines that must run at performance-critical times should be started in advance and we should be particularly careful when using nested coroutines that may contain delayed calls to StartCoroutine().
yield statements within coroutines do not create heap allocations in their own right; however, the values we pass with our yield statement could create unnecessary heap allocations. For example, the following code creates garbage:
yield return 0;
This code creates garbage because the int with a value of 0 is boxed. In this case, if we wish to simply wait for a frame without causing any heap allocations, the best way to do so is with this code:
yield return null;
Another common mistake with coroutines is to use new when yielding with the same value more than once. For example, the following code will create and then dispose of a WaitForSeconds object each time the loop iterates:
while (!isComplete) { yield return new WaitForSeconds(1f); }
If we cache and reuse the WaitForSeconds object, much less garbage is created. The following code shows this as an example:
WaitForSeconds delay = new WaitForSeconds(1f); while (!isComplete) { yield return delay; }
If our code generates a lot of garbage due to coroutines, we may wish to consider refactoring our code to use something other than coroutines. Refactoring code is a complex subject and every project is unique, but there are a couple of common alternatives to coroutines that we may wish to bear in mind. For example, if we are using coroutines mainly to manage time, we may wish to simply keep track of time in an Update() function. If we are using coroutines mainly to control the order in which things happen in our game, we may wish to create some sort of messaging system to allow objects to communicate. There is no one size fits all approach to this, but it is useful to remember that there is often more than one way to achieve the same thing in code.
foreach loops
In versions of Unity prior to 5.5, a foreach loop iterating over anything other than an array generates garbage each time the loop terminates. This is due to boxing that happens behind the scenes. A System.Object is allocated on the heap when the loop begins and disposed of when the loop terminates. This problem was fixed in Unity 5.5.
For example, in versions of Unity prior to 5.5, the loop in the following code generates garbage:
void ExampleFunction(List listOfInts) { foreach (int currentInt in listOfInts) { DoSomething(currentInt); } }
If we are unable to upgrade our version of Unity, there is a simple solution to this problem. for and while loops do not cause boxing behind the scenes and therefore do not generate any garbage. We should favour their use when iterating over collections that are not arrays.
The loop in the following code will not generate garbage:
void ExampleFunction(List listOfInts) { for (int i = 0; i < listOfInts.Count; i ++) { int currentInt = listOfInts[i]; DoSomething(currentInt); } }
Function references
References to functions, whether they refer to anonymous methods or named methods, are reference-typed variables in Unity. They will cause heap allocations. Converting an anonymous method to a closure (where the anonymous method has access to the variables in scope at the time of its creation) significantly increases the memory usage and the number of heap allocations.
The precise details of how function references and closures allocate memory vary depending on platform and compiler settings, but if garbage collection is a concern then it's best to minimize the use of function references and closures during gameplay. This Unity best practice guide on performance goes into greater technical detail on this topic.
LINQ and Regular Expressions
Both LINQ and Regular Expressions generate garbage due to boxing that occurs behind the scenes. It is best practice to avoid using these altogether where performance is a concern. Again, this Unity best practice guide on performance provides greater technical detail about this subject.
Structuring our code to minimize the impact of garbage collection
The way that our code is structured can impact garbage collection. Even if our code does not create heap allocations, it can add to the garbage collector's workload.
One way that our code can unnecessarily add to the garbage collector's workload is by requiring it to examine things that it should not have to examine. Structs are value-typed variables, but if we have a struct that contains contains a reference-typed variable then the garbage collector must examine the whole struct. If we have a large array of these structs, then this can create a lot of additional work for the garbage collector.
In this example, the struct contains a string, which is reference-typed. The whole array of structs must now be examined by the garbage collector when it runs.
public struct ItemData { public string name; public int cost; public Vector3 position; }
private ItemData[] itemData;
In this example, we store the data in separate arrays. When the garbage collector runs, it need only examine the array of strings and can ignore the other arrays. This reduces the work that the garbage collector must do.
private string[] itemNames; private int[] itemCosts; private Vector3[] itemPositions;
Another way that our code can unnecessarily add to the garbage collector's workload is by having unnecessary object references. When the garbage collector searches for references to objects on the heap, it must examine every current object reference in our code. Having fewer object references in our code means that it has less work to do, even if we don't reduce the total number of objects on the heap.
In this example, we have a class that populates a dialog box. When the user has viewed the dialog, another dialog box is displayed. Our code contains a reference to the next instance of DialogData that should be displayed, meaning that the garbage collector must examine this reference as part of its operation:
public class DialogData { private DialogData nextDialog; public DialogData GetNextDialog() { return nextDialog; } }
Here, we have restructured the code so that it returns an identifier that is used to look up the next instance of DialogData, instead of the instance itself. This is not an object reference, so it does not add to the time taken by the garbage collector.
public class DialogData { private int nextDialogID; public int GetNextDialogID() { return nextDialogID; } }
On its own, this example is fairly trivial. However, if our game contains a great many objects that hold references to other objects, we can considerably reduce the complexity of the heap by restructuring our code in this fashion.
Timing garbage collection
Manually forcing garbage collection
Finally, we may wish to trigger garbage collection ourselves. If we know that heap memory has been allocated but is no longer used (for example, if our code has generated garbage when loading assets) and we know that a garbage collection freeze won't affect the player (for example, while the loading screen is still showing), we can request garbage collection using the following code:
This will force the garbage collector to run, freeing up the unused memory at a time that is convenient for us.
We've learned how garbage collection works in Unity, why it can cause performance problems and how to minimize its impact on our game. Using this knowledge and our profiling tools, we can fix performance problems related to garbage collection and structure our games so that they manage memory efficiently.
The links below provide further information on the topics covered in this article.
Further reading
Memory management and garbage collection in Unity
Unity Manual: Understanding Optimization in Unity
Unity Manual: Understanding Automatic Memory Management
Gamasutra: C# Memory Management for Unity Developers by Wendelin Reich
Gamasutra: C# memory and performance tips for Unity by Robert Zubek
Gamasutra: Reducing memory allocations to avoid Garbage Collection on Unity by Grhyll JDD
Gamasutra: Unity Garbage Collection Tips and Tricks by Megan Hughes
MSDN: Boxing and Unboxing (C# Programming Guide)
Object pooling
Unity Learn: Object Pooling Tutorial
Wikipedia: Object Pool Pattern


text:
For an Arthur C. Clarke award-winner (in fact, the very first Arthur C. Clarke award winner), Margaret Atwood has always been leery of the science-fiction label.
Five-time Hugo winner, six-time Nebula winner, and all-around living legend Ursula K. Le Guin called Atwood out on her reluctance in 2009 in her Guardian review of "The Year of the Flood," the third of what Atwood prefers to be called her "speculative fiction" novels. "To my mind, 'The Handmaid's Tale,' 'Oryx and Crake' and now 'The Year of the Flood' all exemplify one of the things science fiction does, which is to extrapolate imaginatively from current trends and events to a near-future that's half prediction, half satire," Le Guin wrote. "But Margaret Atwood doesn't want any of her books to be called science fiction. In her recent, brilliant essay collection, 'Moving Targets,' she says that everything that happens in her novels is possible and may even have already happened, so they can't be science fiction.... She doesn't want the literary bigots to shove her into the literary ghetto."
The Booker Prize winner is hardly the first writer not to want to be crammed headfirst into a too-small box. "I have been a soreheaded occupant of a file drawer labeled 'science fiction' ... and I would like out, particularly since so many serious critics regularly mistake the drawer for a urinal," Kurt Vonnegut wrote in "Wampeters, Foma & Granfalloons." If Bram Stoker were alive, he would likely protest that "Dracula" shouldn't be shelved in the horror section, and Jane Austen would no doubt be adamant that "Pride & Prejudice" was a social satire, not a romance.
Still, Le Guin has a point: If it looks like a futuristic waterfowl, and it quacks like a futuristic waterfowl, does it matter whether it arrived as part of an alien invasion or as a result of genetic mutation?
In her new book of essays, In Other Worlds, Atwood answers Le Guin, to whom the book is dedicated. "The motive imputed to me is not in fact my actual motive for requesting separate names.... What I mean by 'science fiction' is those books that descend from H.G. Wells's 'The War of the Worlds,' which treats of an invasion by tentacled, blood-sucking Martians shot to Earth in metal canisters – things that could not possibly happen – whereas, for me, 'speculative fiction' means plots that descend from Jules Verne's books about submarines and balloon travel and such – things that really could happen but just hadn't completely happened when the authors wrote the books." (Fair enough, but I've heard them both Wells and Verne described as the "father of science fiction.")
While she may not think she writes it, Atwood certainly has read a fair bit of and thought deeply about science fiction, and she shares generously with her readers in "In Other Worlds," starting with the flying rabbits she wrote about as a child. (The be-caped bunnies and other illustrations by Atwood are featured on the whimsical end-papers.)
"In Other Worlds" is divided into sections: The first part covers three of Atwood's never-before-published lectures, covering the ground from superheroes to science fiction as the modern refuge of religious writing – "I'm far from the first commentator to note that science fiction is where theologically linked phenomena and reasonable facsimiles of them went after 'Paradise Lost' " – to utopias and dystopias. That last, "Dire Cartographies," is the most interesting, covering her abandoned thesis and the genesis of "The Handmaid's Tale." "My rules for 'The Handmaid's Tale' were simple: I would not put into this book anything that humankind had not already done, somewhere, sometime, or for which it did not already have the tools."
In the second section, Atwood reviews works such as H. Rider Haggard's "She" (origin of the original "She-who-must-be-obeyed"), Aldous Huxley's "Brave New World," George Orwell's "Animal Farm" and "1984," Le Guin's "The Birthday of the World, and Kazuo Ishiguro's "Never Let Me Go." Atwood is particularly good on Huxley and Orwell. "The twentieth century could be seen as a race between two versions of man-made Hell – the jackbooted state totalitarianism of Orwell's '1984' and the hedonistic ersatz paradise of 'Brave New World....' " Especially enjoyable is her discussion of the mad scientists in the third section of Jonathan Swift's "Gulliver's Travels." And I wish the scientists who recently decided to recreate the Black Plague to see just what made it so deadly had read her review of Bill McKibben's nonfiction work, "Enough."
Finally, Atwood includes four already published short stories, covering such concerns as cryogenics and why it will never, ever work, to alien invasions, winding up with an excerpt from my favorite of her novels, "The Blind Assassin."
One quibble: Could Atwood's editors not have helped her out with a few errors, such as "Attack of the 60 Foot Woman," which I'm guessing was a typo, and the fact that Wonder Woman's invisible flying vehicle was a plane (later a jet, later discarded when she got the power of flight, later – who knows? I lost track after she finally got some pants), not a "helicopter?"
Any review that leads to memories of flying rabbits has performed a service to humanity in my book, and I just have one question for Le Guin: Could you please retroactively review "The Blind Assassin?" (It has the lizard men of Xenor and everything!) I'd really love to read more on that book.
Yvonne Zipp regularly reviews fiction for the Monitor.

subset: commoncrawl


text:
Great Britain's gold medal brigade continued today as Andy Murray, who just four weeks ago was thrashed on Centre Court by Roger Federer, defeated Fed in straight sets 6-2, 6-1, 6-4.
For British tennis fans starved for a Wimbledon champ, it was a bittersweet victory, like learning your spouse bought you a vintage Porsche only to discover they bought a 914. Still, it's awesome to see albeit heartbreaking for Federer, who long dreamed of Olympic gold—although he certainly didn't seem too into it today. Here's the call as it was heard by native Brits. [BBC]
For a handy master schedule of every Olympic event, click here.


text:
Pastels and pies and everything nice came together for this beautiful DIY wedding at the Brock House Restaurant, one of Vancouver's most sought after wedding venues because of its ocean view. We love the details captured by Blush Wedding Photography! In the bride's words : "Ian and I grew into adulthood together, and so the […]
Heirloom Magazine | Vancouver Wedding Magazine
Vancouver wedding magazine filled with vintage inspiration for the modern bride | A focus on weddings, marriage advice, DIY projects, home decor, wedding planning and all that comes after.
Tag Archives: diy brides


text:
20' Aeration Windmill System
Product Details
About this item
A free-air, wind generated pond aeration system that creates clean, oxygenated water.
current price: $1,649.00
Online only
Wind driven aeration system is extremely effective in adding oxygen to ponds, reducing algae, bacteria, odor and fish loss due to the lack of oxygen in the water. This system effectively aerates 2-3 acre ponds and the windmill can be placed up to 1,000 ft. away from the body of water.
The Outdoor Water Solutions Aeration Windmill System was designed by a team of engineers utilizing our innovative "BalCam II" technology available for wind driven aeration and its patent pending design allows the windmill to produce 3.0 - 4.5 CFM of air and 30 PSI.
- Do not climb on tower.
- Do not attempt to repair or service the windmill in high wind situation.
- We recommend laying the windmill down when working on it vs. trying to do repairs while it is standing.
- A sudden gust of wind can physically turn the rotor head causing possible injury.
- Do not get near the windmill in high wind situations or a thunderstorm.
- Do not allow children to play on or near windmill.
Policies & plans
- System is extremely effective in adding oxygen to ponds, reducing algae, bacteria, odor and fish loss due to lack of oxygen in the water
- Effectively aerates from a ¼ acre up to a 3 acre pond and can be placed up to 1000 ft. away from the body of water
- Has a self-governing head to protect itself in heavy winds
- Includes parts for 1 windmill head, tower, 100' of 1/2" polytubing airline, 1 Airstone, and 1 complete installation manual
- "BalCam II" technology revolutionizes the industry by significantly increasing the amount of air produced with a single diaphragm, utilizing our balanced camshaft system. Now in stainless steel!
- 20 ft. tall
- Patent pending design allows the windmill to produce 3.0 - 4.5 CFM of air and 30 PSI
- Assembled size: 9'L x 9'W x 22'H
For questions or concerns regarding this product, please contact our customer service department at 1-866-471-1614.
Warranty covers windmill products for 3 years from purchase date against defects in workmanship and five years from purchase date against defects in the compressor
Assembled Country
Component Country


text:
The Tryane II is an example of fine craftsmanship by a guy who is aptly named Friend Wood. He spent 2000 hours building the car; a key part of that process involved gluing and stapling together strips of mahogany veneer, and then buffing it to a mirror-like finish.
It's gorgeous, and weighs just 900 pounds. It actually has an internal combustion engine inside that's said to be capable of 70 to 90 miles per gallon. Wouldn't that be a fire hazard? And, we'd hate to see what would happen if this thing got into an accident, splintering up like so many pieces of balsa wood.
But those practical considerations are beside the point. The car will probably end up functioning as a really unusual, one-of-a-kind coffee table, or at least in a coffee table book.
How he did it [Friend Wood, via Born Rich]


text:
Our Monastery is named after the Holy Transfiguration of our Lord and Saviour Jesus Christ, which is one of the greatest events that took place in the history of our Lord's life on earth, and consequently is celebrated in our Church as one of the greatest feast days of the year. We celebrate the feast day of our monastery on August 5th and 6th every year. Everyone is welcome to attend - please check our website a few days before the event for schedules and other information.
The small chapel that we have at the Monastery is dedicated to St. John the Evangelist and Theologian. All of our daily services are held in this chapel. We also have a smaller celebration of the feast day of St. John the Theologian, which according to the Church calendar takes place on May 7th and 8th every year.
Besides being busy with the upkeeping of the grounds, many handicrafts are made at the Monastery. Some of them, accordingly wrapped, are available as gifts for baptisms and weddings. Also, monastic clothes are custom tailored at the Monastery, as well as vestments, rhasa, and hats for Orthodox clergy. We also make pure beeswax candles. The above-mentioned items and handicrafts can all be viewed by locating them on the menu on the left.
The gate is open daily between 6:00 am and 7:00 pm, and everyone is welcome to visit. If you would like to speak with one of the monks, or make an appointment for confession, then it is better that you schedule an appointment beforehand. Visit the contact us page for more details. Please also note that you may now download the 40-day Liturgy Form from this website (for commemoration of the living and the reposed) in order to send them to the Monastery.
The feast our Church celebrates on August 6th commemorates the transfiguration, or metamorphosis, of Christ on Mount Tabor, when our Lord appeared in His divine glory before three of His disciples. You can read an account of the Holy Transfiguration in the book of Luke 9:28-36, or click here to read these verses on our website.
According to the New Testament, Our Lord took three of His disciples (St. Peter, St. Iakovos, and St. John the Theologian), to the top of Mt. Tabor, where He was transfigured by showing them some of His glory (as much as they could handle), in the presence of the two Holy Prophets Elias and Moses. St. Isidoros Pelousiotis explained that the appearance of the two Holy Prophets during the Transfiguration, along with the presence of the three disciples, indicate and affirm that Our Lord Jesus Christ is in total control of both the living and the dead.
It is very significant that The Lord's Transfiguration took place before his arrest. After His disciples witnessed His awesome glory and tremendous power, they then saw Him humiliated in the most disgraceful ways, and eventually put on The Cross. Then they could realize that He suffered everything because of His infinite, truthful, and unconditional love towards each one of us individually, and that He wants all of us to be with Him eternally.


text:
Top News:
Andrew Beaujon / Poynter:
Jonah Lehrer talks about plagiarism at Knight lunch for $20,000 fee — At a talk this afternoon in Miami, Jonah Lehrer acknowledged his plagiarism and fabrications and talked about how he hopes to redeem his reputation. Lehrer read prepared remarks and answered questions from Knight Foundation President …
Discussion: Politico, Forbes, FishbowlNY, Erik Wemple, @jeffbercovici, Knight Foundation, @juliemmoos, @mlcalderone, @sdkstl, @craigsilverman, @deggans, @alexweprin, @jeffsonderman, @jeffsonderman, @chanders, @isaacdovere, @pauljgoldsmith, @jeremylittau, @dylanbyers, @brianvastag, @robertafking, @marawritesstuff, @profjeffjarvis, @megan, @joeheim, @dylanbyers, @kissane, @themarkberman, @megan, @stevesilberman and @dylanbyers
Dylan Byers / Politico: Jonah Lehrer paid $20k to talk plagiarism
Jeff Bercovici / Forbes: Jonah Lehrer Thinks He Can Humblebrag His Way Back Into Journalism
Chris O'Shea / FishbowlNY: Jonah Lehrer: I Lied Because I'm Smart [Update]
Jeff Bercovici / @jeffbercovici: Jonah Lehrer equating his individual mistakes with FBI's institutional failings, but institutions don't have intention. #infoneeds
Julie Moos / @juliemmoos: Jonah Lehrer was paid $20,000 by Knight to speak at today's lunch: http://journ.us/XvVM21 He confessed plagiarism, fabrication in the talk
Michael Calderone / @mlcalderone: Amazing that Knight Foundation, which funds "journalistic excellence," paying plagiarist/fabricator $20,000 for talk: http://journ.us/XvVM21
Staci D Kramer / @sdkstl: Get that Jonah Lehrer needs to make a living but hope he turns most or all of that $20k back to Knight. #infoneeds
Craig Silverman / @craigsilverman: Oh jeez. Lehrer getting $20,000 to speak at #infoneeds really undermines what he was ostensibly trying to do: http://www.poynter.org/latest-news/ mediawire/204005/jonah-lehrer-talks- about-plagiarism-at-knight-lunch/ ...
Eric Deggans / @deggans: Holy crap MT @juliemmoos: Jonah Lehrer was paid $20,000 by Knight to speak http://journ.us/XvVM21 He confessed plagiarism, fabrication in talk
Alex Weprin / @alexweprin: Knight Foundation: The morning TV of journo non-profits RT @abeaujon: Knight paid Jonah Lehrer $20K for speech. http://bit.ly/VSDIMn
Jeff Sonderman / @jeffsonderman: RT @kelseyproud: @jeffsonderman 20K - you mean roughly the intro salary for some journalism jobs? Oy.
Jeff Sonderman / @jeffsonderman: Who knew a career in journalistic fabrication could be so lucrative? http://www.poynter.org/...
@chanders: The amount Jonah Lehrer got paid by the Knight Foundation to speak today- $20,000— is almost 40% of US median household income for a year.
Edward-Isaac Dovere / @isaacdovere: how long until Jonah Lehrer's weepy book deal about the fascinating brain science that led him to all the plagiarizing and invention?
Paul Goldsmith / @pauljgoldsmith: Twitter's new era of awkward: People tweeting insults on big screen behind author @jonahlehrer while he apologizes for lying. #infoneeds
Jeremy Littau / @jeremylittau: Good for @JonahLehrer. Few plagiarists, in my experience, realize part of what made them do it is view of their own intelligence. #infoneeds
Dylan Byers / @dylanbyers: Actually, this Jonah Lehrer apology is actually abdication of responsibility masked as assumption of responsibility.
Brian Vastag / @brianvastag: This Jonah Lehrer talk people are tweeting about sounds like one of the most boring things of all time. #lunch
@robertafking: That Jonah Lehrer speech was one of the more uncomfortable events in my recent memory. #infoneeds
Mara Wilson / @marawritesstuff: Any humiliation fetishists should be checking out the Jonah Lehrer livestream now #infoneeds
Fake Jeff Jarvis / @profjeffjarvis: .@mdaisy Do you agree with Jonah Lehrer that we are in a post-truth era of thinkfluence?
Megan McCarthy / @megan: If Jonah Lehrer were to come out and say "I scammed my way into the New Yorker and *here* is how I did it," that might be interesting.
Dylan Byers / @dylanbyers: Jonah Lehrer: "If I write again, then what I write will be fully fact-checked and footnoted."
Erin Kissane / @kissane: Jonah Lehrer is a real person. Twitter is making me so uncomfortable right now.
Mark Berman / @themarkberman: Jonah Lehrer's reemergence reminds me of [anecdote about a recent study], which [fabricated quote] before [plagiarism] and [plagiarism]
Megan McCarthy / @megan: Jonah Lehrer really needs to get over himself.
Steve Silberman / @stevesilberman: "I'd like to end with a quote from Bob Dylan. One he actually said." - @jonahlehrer #infoneeds
Jim Romenesko:
Jonah Lehrer: 'My mistakes have caused deep pain to those I care about' — Here is the opening of Jonah Lehrer's speech at the Knight Foundation's Media Learning Seminar: — "I'd like to begin by thanking the Knight Foundation for the invitation to speak.
Kara Bloomgarden-Smoke / The New York Observer:
Jim Roberts Goes to Reuters — Jim Roberts, who took the Times buyout last month, is going to Reuters. Mr. Roberts will be the executive editor of Reuters digital, Reuters digital editor Chrsytia Freeland announced in a staff memo today. Mr. Roberts was the Times assistant managing editor and has a devoted Twitter following.
Discussion: Talking Biz News, @craigsilverman, @harrisj, @nycjim, @andreaitis, @justinnxt, @kathrynschulz, @nytfridge, @a_kowalsky, @riazat_butt, @gretawire, @joepompeo, @brianstelter, @kenli729, @tcarmody, @kenvogel, @moorehn, @kenli729 and Poynter
Craig Silverman / @craigsilverman: RT @ShortFormErnie: That is a massive get. Congrats to team Reuters. RT @TheMatthewKeys: Welcome @NYCJim to @Reuters. #FF
Jacob Harris / @harrisj: Congrats to @nycjim on his new gig. He could've at least spent a year sailing around the world or herding goats first though.
Jim Roberts / @nycjim: Super excited to be joining @cafreeland & other smart journos at Reuters. What a gig! Here's her memo: http://bit.ly/XyKNRU
@andreaitis: @alexrkonrad [tossing hat in air] RT I think this @nycjim guy is gonna make it after all.
Justin Ellis / @justinnxt: If you had WSJ, Guardian, or BuzzFeed in the @nycjim betting pool, tear up your ticket: http://observer.com/2013/02/jim- roberts-goes-to-reuters/ ... Congrats Jim!
Kathryn Schulz / @kathrynschulz: Nice to see proof that people who excel at their work don't go without it for long. Congrats to @nycjim on his new gig: http://bit.ly/XwoyzE
@nytfridge: In which @nycjim, a young newsman of some promise is named Executive Editor of @Reuters digital. Via @TalkingBiznews http://bit.ly/VRaUsN
Alex Kowalsky / @a_kowalsky: Omg. @nycjim + @TheMatthewKeys + @AntDeRosa = Twitter takeover. Watch out if DARPA calls.
Riazat Butt / @riazat_butt: No idea who @nycjim is but I believe congratulations are in order. Is there a UK equivalent of such a move? A football analogy would do
Greta Van Susteren / @gretawire: @romenesko unemployment for him did not last long...i like reading Jim Roberts news tweets
Joe Pompeo / @joepompeo: So @nycjim replaces @jimpoco. Job passes from one former high-ranking @nytimes editor to another.
Tim Carmody / @tcarmody: That is amazing. RT @Megan: So excited about this. Welcome @nycjim! RT @NewYorkObserver: Jim Roberts goes to Reuters. http://nyob.co/XH5pJH
Kenneth P. Vogel / @kenvogel: Congrats - hope Reuters Twitter policy isn't restrictive! MT @Poynter: @nycjim to Reuters Digital after @nytimes buyout http://journ.us/X2BmxZ
Heidi N. Moore / @moorehn: This only confirms my theory that all journalists end up working for Reuters or Bloomberg.
Kenneth Li / @kenli729: uhm RT @theglipper: (Wonder if @nycjim is going to take over the @ReutersHulk account ...)
Andrew Beaujon / Poynter: Jim Roberts joins Reuters
Julia Ioffe / The New Republic:
Ezra Klein: The Wise Boy — A tale of striving and success in modern-day Washington. The first time I interviewed Ezra Klein, the 28-year-old prince of D.C. media, he brought me a sandwich: prosciutto on a poppy-seed baguette. (Also, chips and a beverage.)
Alex Balk / The Awl: How To Not Be Ezra Klein
Glenn Greenwald / @ggreenwald: There were a lot of interesting angles TNR could have explored in that Ezra Klein piece. It chose none of them.
Alec MacGillis / @alecmacgillis: "My only advice is...always try to be the talent." The @juliaioffe profile of @ezraklein: http://www.newrepublic.com/article/ 112366/ezra-klein-profile-wonkblogs- wise-boy-cannot-be-stopped ...
Richard Beck / @richbeck: "I wear jeans, not suits, for instance." -Ezra Klein http://www.newrepublic.com/article/ 112366/ezra-klein-profile-wonkblogs- wise-boy-cannot-be-stopped# ...
Kimble McCraw / @kimblem: I thought @fivethirtyeight made me feel under-ambitious, then I learned that @ezraklein is 28. http://www.newrepublic.com/article/ 112366/ezra-klein-profile-wonkblogs- wise-boy-cannot-be-stopped# ...
Sean Davis / @seanmdav: These pictures are what happen when you have no self-awareness and your wife isn't around to tell you to knock it off: http://www.newrepublic.com/article/ 112366/ezra-klein-profile-wonkblogs- wise-boy-cannot-be-stopped ....
Simon Owens / @simonowens: This TNR profile of Ezra Klein is definitely one of the more meta pieces I've read in awhile http://on.tnr.com/UamMEA
Andrew Exum / @abumuqawama: "You're a journalist, right?" I asked him. "I am," he agreed. "And I try to be responsible about it." http://www.newrepublic.com/article/ 112366/ezra-klein-profile-wonkblogs- wise-boy-cannot-be-stopped ...
Conor Sen / @conorsen: This @ezraklein profile is inspiring to those of us who don't fit into pre-2005 institutions very well: http://on.tnr.com/158GsvR
@daveweigel: NSFW RT @brianbeutler: In which I reveal the juicy truth about @ezraklein's work ethic http://on.tnr.com/YolBy5
Jay Rosen / @jayrosen_nyu: Ezra Klein has "f**k you" traffic, says an editor at the Washington Post. Enough to halt any argument with an editor. http://on.tnr.com/XvEuCo
Jeff Bercovici / @jeffbercovici: Great profile of @ezraklein by @juliaioffe. Remember, kids, it only hurts if you don't relax. http://www.newrepublic.com/article/ 112366/ezra-klein-profile-wonkblogs- wise-boy-cannot-be-stopped# ...
Felix Salmon / @felixsalmon: Ezra Klein's high-school GPA will surprise you http://www.newrepublic.com/...
Matt Yglesias / @mattyglesias: In which I reveal the SHOCKING TRUTH about hilarious @EzraKlein anecdotes: http://www.newrepublic.com/article/ 112366/ezra-klein-profile-wonkblogs- wise-boy-cannot-be-stopped ...
Kevin W. Glass / @kevinwglass: "He must be brilliant! He must read all the time!" http://on.tnr.com/XylJKB
Mike Madden / @mikemadden: Ezra Klein, says @TNR, "was the good grandson delivering an intelligent and schticky bar mitzvah speech." http://www.newrepublic.com/article/ 112366/ezra-klein-profile-wonkblogs- wise-boy-cannot-be-stopped ...
Janko Roettgers / GigaOM:
Erik Huggers: Intel will launch its own TV service this year — Intel Media boss Erik Huggers finally broke his silence about the company's TV plans at All Things Digital's Dive into Media conference in Dana Point, California Tuesday, confirming reports from GigaOM and others that the company …
Discussion: AllThingsD, Adweek, CNET, AllThingsD, TechCrunch, The Wrap, Broadcasting & Cable and The Next Web
John Paczkowski / AllThingsD: Yes, Intel Is Building a Web TV Service (A Box, Too)
Mike Shields / Adweek: Intel to Shake Up TV Landscape This Year
Shara Tibken / CNET: Intel confirms it's building an Internet TV service and box
Ryan Lawler / TechCrunch: Intel Will Roll Out Its Virtual Cable Service Under A New Brand Later This Year
Lucas Shaw / The Wrap: Intel to Launch Web TV Service By Year's End
Salvador Rodriguez / Los Angeles Times:
Intel confirms Internet TV service and set-top box are on the way — Intel announced it is working on a new Internet TV service and a set-top box. (John G. Mabanglo/EPA) — Intel announced Tuesday it is working on an Internet TV service and set-top box that it hopes to roll out within a year.
Dylan Byers / Politico:
Washington Post erroneously reports Sarah Palin joining Al Jazeera — The Washington Post has erroneously reported that Sarah Palin, the former vice presidential candidate and former Fox News contributor, is joining the Qatari-owned news network Al Jazeera.
Discussion: Washington Post, Mediaite, FishbowlDC, The Stream, The Week, The Huffington Post, TVNewser, The Daily Caller, New York Magazine and National Review
Suzi Parker / Washington Post: Sarah Palin tries to stay relevant
Noah Rothman / Mediaite: Parody Website Fools The Washington Post Into Thinking Sarah Palin Heading To Al Jazeera
Jason Linkins / The Huffington Post: Sarah Palin Wins Correction Of The Day After WaPo Runs Patently Unbelievable Al Jazeera Scoop
Alex Weprin / TVNewser: No, Sarah Palin Isn't Joining Al Jazeera America
Joe Coscarelli / New York Magazine: Sarah Palin Not Joining Anti-American Terrorist Mouthpiece at the Moment [Updated]
Nathaniel Botwinick / National Review: Washington Post Will Believe Anything About Palin
Ina Fried / AllThingsD:
Hearst's David Carey on How People Are Still Reading Magazines. Really! — Despite what you may have read online, the print magazine business is actually pretty good. — Or so says Hearst Magazines President David Carey. — "A lot of magazines get tarred with a lot of the anxiety around …
Jeff John Roberts / paidContent: Hearst: Women finally embracing online magazines thanks to 7-inch screens
Shara Tibken / CNET:
Inkling takes on Amazon, Apple with new e-book publishing tool — The startup, founded by a former Apple executive, also has allowed users to search via Google within titles made using its technology. — The launch of Amazon's first Kindle e-reader in 2007 upended the publishing industry.
Discussion: Reuters, PublishersWeekly.com, TechCrunch, paidContent, VentureBeat, Businessweek and Digital Book World
Jennifer Saba / Reuters: Inkling takes aim at Amazon
Rip Empson / TechCrunch: Inkling Takes Dead Aim At Apple And Amazon With New Google Search-Friendly Digital Publishing Tools
Laura Hazard Owen / paidContent: Inkling makes its Google-friendly digital publishing tools free to everyone
Devindra Hardawar / VentureBeat: Inkling Habitat brings pro-level digital book creation to the cloud — but will it dent Amazon?
Danielle Kucera / Businessweek: Building a Better E-Book (Than Amazon and Apple)
Roy Greenslade / Guardian:
James Harding in talks on senior BBC role — Former Times editor could join corporation in one of several vacant positions, including director of news — James Harding, the former editor of the Times, has been in talks with the BBC's incoming director general, Tony Hall …
Discussion: @lisaocarroll and @benfenton
Lisa O'carroll / @lisaocarroll: Exclusive. Could ex Times editor James Harding be in talks to be deputy DG at the BBC? http://gu.com/p/3dm8t/tw via @guardian
Dylan Byers / Politico:
Jake Tapper's new show: 'The Lead' … CNN has announced the name of Jake Tapper's new show. — The program will be called "The Lead." CNN has started promoting the show and Tapper confirmed the title via Twitter. — CNN announced yesterday that it had hired MSNBC's Federico Quadrani …
Discussion: Hollywood Reporter, The Huffington Post, Variety, Multichannel News, Reuters and CNN
Marisa Guthrie / Hollywood Reporter: Jake Tapper to Get 4 P.M. Slot on CNN
Katherine Fung / The Huffington Post: Jake Tapper's CNN Show Gets Name
Ted Johnson / Variety: CNN reveals details of Jake Tapper show
Andrea Morabito / Multichannel News: Jake Tapper's CNN Show Gets 4 P.M. Timeslot, Executive Producer
Alexander C. Kaufman / Reuters: CNN slots Jake Tapper Show, cuts length of Wolf Blitzer's 'Situation Room'
Rebecca Berg / BuzzFeed:
Capitol Hill Is Obsessed With "House Of Cards" — WASHINGTON — On Sunday night, Beau Willimon, the showrunner, co-creator and executive producer of the new Netflix show House of Cards, received an email from his close friend, Mike Lynch, the chief of staff to Sen. Chuck Schumer.
Discussion: mediabistro.com
James Crugnale / mediabistro.com: Morning Media Newsfeed 02.12.13
Jim Romenesko:
WSJ managing editor: Bloomberg is our biggest competitor — When asked who Dow Jones' biggest competitor was, he said, "Competitor or competitors?" When the questioner kept it singular, Gerry paused for a moment then responded, "Bloomberg." He said the answer was based on both what the company …
Discussion: Capital New York and Talking Biz News
Joe Pompeo / Capital New York: The Wall Street Journal rank-and-file is slowly getting to know its new captain.
Conservatives publish draft royal charter on press regulation — Lord Leveson's report was published in November — Prime Minister David Cameron rejected Lord Justice Leveson's recommendation, backed by Labour and the Lib Dems, that a new system be underpinned by statute.
Discussion: Press Gazette, Guardian, @skynewsbreak, Sky News, Spectator and Hacking inquiry
Andrew Pugh / Press Gazette: Hacked Off reject Tory Royal Charter plan as "Leveson defiant" not compliant
@skynewsbreak: Culture Sec Maria Miller publishes plans for Royal charter to implement Leveson Report principles to create "toughest press regulation"
Isabel Hardman / Spectator: Cross-party consensus on Leveson tested with Royal Charter plan


text:
Spotting Dyslexia Warning Signs
A person with dyslexia struggles on a long-term basis with written (and sometimes spoken) words, even though she's bright (or extra bright) in other areas. A whole cocktail of symptoms tells a psychologist that your child has dyslexia, and you can find a list on the BDA website to help you further, but warning signs include the following:
Lack of interest in letters and words at a young age, although shows enjoyment with being read to.
Inability to identify rhyming words (like hat, pat and fat) and word patterns (like Bill, bear, bun, bed and ball, which all begin with 'buh') at an early age.
Difficulty remembering names of familiar objects, numbers, colours and shapes at an early age.
Inability to remember sequences of numbers (like their telephone number) or letters (like the alphabet) or fast facts (like multiplication tables).
Extreme difficulty with reading. A child with dyslexia may leave out little words (like of), misread small everyday words (like they) even though she reads some harder words. She may read similar-looking words instead of actual words (like was for saw and horse for house) or read words that are similar in meaning instead of actual words (reading little for small or lovely for pretty).
A child with dyslexia may read words that make no sense, but have one or two letters that are in the actual word (like tall instead of lot because both words have l and t in them). A child with dyslexia may, for example, read 'There were a lot of roses growing all around Jane's house' as 'There was a tall flowers growing around Jane's horse'.
Extreme difficulty with spelling. A child with dyslexia may transpose letters (aleiv instead of alive), leave out letters (aliv), add letters (alieve) and reverse letters (typically b and d). She may also write words phonetically (exactly as she hears them), producing spellings like becuz, wur and thay.


text:
Russia qualify for FIVB World Grand Champions Cup, World Championships
The world No. 6 team defeated No. 9 Germany 3-1 (25-23, 23-25, 25-23, 25-14) at the 2013 CEV Volleyball European Championship – Women in Berlin on Saturday.
"It was definitely our toughest game," said Russia's head coach Yuriy Marichev following the game. "I told my players to focus on our strength at the net. It helped. I am very happy."
As the winner of the 2013 CEV Volleyball European Championship – Women, Russia have qualified for the 2013 FIVB Volleyball World Grand Champions Cup featuring a total of six teams per gender with the hosts Japan being joined by the continental winners from Asia, Europe, NORCECA and South America with an additional country selected by the FIVB.
The five best-ranked teams of the 2013 CEV Volleyball Women's European Championship – Russia, Germany, Serbia, Croatia and Italy – as well as the organizers from Belgium and the Netherlands have qualified for the 2015 CEV Volleyball European Championship – Women.
Despite their loss on Saturday, Germany also qualified
for the 2014 FIVB Volleyball Women's World Championship, as the two best-ranked
teams are allotted a spot.
The first World Championships were organised in 1949 for Men and 1952 for Women. Both gender events have remained the biggest events in volleyball, along with the Olympic Games since 1964.
For further information visit www.eurovolley2013.org and www.cev.lu for detailed match statistics.


text:
Are you totally stoked for you first year at college? We hope you are, because we're about to give you some pretttty, prettttty, important insights into your first week. We've already been there and done that, so we've got your back, bro.
1. Dining hall food is the worst Yeah, the way your school's website described the "gourmet" food from the dining hall made it seem like goddamn Gordon Ramsey himself was in the kitchen. Nope. The only thing screaming G. Ramsey style are your bowels as you sit in the bathroom for two hours trying to remember if you ate shame or humiliation for dinner.
2. Eating alone doesn't make you totally weird No, seriously, eating alone is probably the optimal choice. Sitting next to that one guy you met in your sociology class while you both shovel taco surprises into your mouths in complete silence is weirder than just eating by yourself. Pressure's off man, eat all the taco surprise you want and listen to your iPod. We're not here to judge.
(Strive to be half as cool as this guy)
3. You don't have to wear flip flops in the showerListen, the showers are gross. We know. But let's also face the fact that dorms, in general, are the VDs of the architectural world. Flip flops aren't going to protect your feet from whatever goes on inside those shower stalls. It's college, live on the edge. No shoes, full service!
4. You definitely aren't invited to that party Freshman year is tough. You're underage, you can't go to the bars, you don't know many people and you've reinvented yourself into a douche. It's okay, it happens to the best of us. But listen, you're definitely not invited to that house party. It isn't because you're unpopular, it's because you're a freshman, and everyone hates you.
(Stop looking so sad, everyone hates freshman!)
5. Your roommate farts in their sleep Ah, yes, the phantom farter. It's your first week away at school, and after you've cried yourself to almost-sleep because you, like, totally don't fit in at this school and you'll never make any friends, your roommate's body decides to give you another reason you should have gone with a single. Maybe tomorrow night their butt will take song requests.
6. Don't count on going to the gymNo pain, no gain, buddy. And it seems the only pain you're in is a product from last night's frat party. Yeah, yeah, you'll start going to the gym tomorrow, you've had a rough first week at college. There're other people like you, too, like mostly everyone. Embrace it, and your newly emerging beer belly.
(You listed Homer Simpson as your personal hero on your application essay, anyway.)
7. There's always a couple breaking up somewhere in your dorm And you're an unwilling participant to all of it. Sorry, but you're now right in the middle of a very dull drama called "We Only Slept Together Once, Please Stop Calling Me" starring your roommate and that chick from the third floor.
8. Your first in-college one-night-stand is super awkward Spoiler alert: you guys definitely don't fall asleep intertwined as the distant sound of a babbling stream mixes with the brisk summer air. No, it's more like it's really fucking hot in the room and you're both sweating profusely and pretending to sleep. Also, is someone puking outside the window? Also all of your extremities have fallen asleep. Happy sexing!
9. You're going to switch majors Oh, neuroscience isn't what you expected? We know, it's only the first week and it's like they want you to actually work hard. No way, time to business major the fuck outta this school.
10. You aren't going to hang out with anyone from your orientation You've grown apart since orientation two months ago. They live in a dorm, you live in another dorm that's like, all the way across campus. You're different people, with different class schedules now. It's time to move on and become friends with people in your OWN dorm. Except Steve. Avoid Steve at all costs, he's totally creepy.
(It's okay you don't want to talk anymore, this picture exists to prove you did some icebreakers together)
11. That fake I.D. doesn't work Yeah, yeah, that sketchy third time senior said these would totally legit, but they aren't. Aside from the fact that you clearly just turned 18, maybe, 888 This Is An Address doesn't sound like a real place, Greg from "Arizona".
12. Your new self proclaimed nickname won't stickOh you're going by "Gregster" now? Hm, nice choice. I'm going to keep calling you Greg, if that's okay.
13. You probably didn't need to buy a brand new MacBookWe know it's a new chapter in your life, and you're ready to buckle down and work. But you just paid 2 grand for Facebook and Microsoft Word. Oh, sometimes you like to remix songs on GarageBand? Congrats, you're already a douchebag, and it's only your first week of college.
(We know you have a Family Guy Skin for it, too, don't lie to us.)


text:
State license requirements for professions ranging from fumigators and ginseng nurserymen to horse traders and hair braiders may cost Arizona more than half a billion dollars annually in lost economic activity, according to a new analysis from the Goldwater Institute.
In Six Reforms to Occupational Licensing Laws to Increase Jobs and Lower Costs, Goldwater Institute economist Byron Schlomach, Ph.D., details how government-required licensing hurts all Arizonans—job-seekers, consumers, and licensed professionals alike.
According to Schlomach's analysis, licensing is harmful to job-seekers because it creates difficult barriers to entry for many professions. Schlomach as an example, obtaining a cosmetology license in Arizona requires 1,450 hours of costly training at a cosmetology school, followed by $142 in exam fees and a combined 372 days of education and experience. "Licensing discourages people from entering an occupation in which they might succeed if their success hinged only on the satisfaction of customers," said Schlomach.
Schlomach's says that the practice of licensing hurts consumers too, because it drives up the costs of available services. Ultimately higher prices hurt licensed service-providers themselves, according to the Schlomach's analysis. "In response to higher prices, consumers either learn to do without those services or they do with less, thereby reducing their purchases of services from the licensed profession," Schlomach noted.
Schlomach estimates that licensing may cost Arizona as much as $660 million annually in lost economic activity.
This is not just about dollars and cents. Schlomach's says that licensing requirements can intimately impact people's daily lives. Consumers may forgo modest medical treatments because the cost to have a doctor perform the procedure is prohibitive. But if the treatment were allowed to be administered by a nurse or other professional, the price may be more affordable, putting the treatment financially within reach. Some people die without preparing a last will and testament, because an expert in will preparation cannot legally sell his services without completing law school and passing the bar exam, even if they never perform any other legal service besides will preparation.
Most licensing requirements are put in place in an effort to protect people from a dangerous or fraudulent service. In some cases licensing can protect consumers. But in other cases, requiring a person to be licensed doesn't protect people at all. For example, some states require people to be licensed if they want to be called an interior designer. But interior designers can't design the structure of a house or business. An interior designer is the person who picks the color scheme and decorative touches. Consumers don't need the government to protect them from a bad paint job, says Schlomach.
Schlomach says strengthening the punishments for committing fraud could eliminate the need for some licensing requirements. "If a professional misrepresents who they are or the skills they have and someone gets hurt, they should be held accountable. And that can be done with existing laws, we don't have to require a government license too," said Schlomach.
An estimated 800 occupations are licensed in at least one state. In Arizona about 85 professions are required to be licensed by the government, making up approximately 10 percent of the state's workforce.
In Six Reforms to Occupational Licensing Laws to Increase Jobs and Lower Costs, Schlomach identifies common-sense reforms that could open career opportunities and reduce prices without sacrificing consumer safety, including "sunrise" provisions to require licensing advocates prove the barriers are needed before they are enacted, and a requirement that all licensing laws be periodically reviewed to make sure they are meeting a real consumer safety function. Schlomach also recommends that licensing boards have a supermajority of members drawn from the general public rather than the licensed profession itself.


text:
Putinisms: Vladimir Putin's Top Six One Liners
Russian President Vladimir Putin compared U.S. involvement in the Ukraine to experimentation with rats. Here are WSJ's Jason Bellini's six favorite "Putinisms".
This transcript has been automatically generated and may not be 100% accurate.
Russian President bloodwork and likens U S involvement in Ukraine to ... scientific experiments ... that like they're in a lavender running all sorts of experiments on the rocks without understanding the consequences of what they're doing ... at school one of our subjective list of Mr Putin's most colorful comments ... Mr prudent has a flair for folksy idioms for instance when he announced he would not be handed over NSA whistleblower Edward Snowden to America ... because to do so would be ... like during ... lots of squealing ... these ... pigs of course have no CME's ... deal with Russian saying reports the Republic is a metaphor for hard thankless work ... the former KGB agent who like to project an alpha male and occasionally topless image ... was publicly threatened the manhood of Chechen rebels ... if you want to become a real radical Islam to prepare to be circumcised ... an invite to Moscow said ... you have nothing left to go back ... to some more matches Russia's Mafia ... you must obey the laws and ways not only when they grab you by your special place ... that has been coming under heavy criticism for being not so special place for gays and lesbians ... Mr prudent insists he has no problem getting people to an interviewer ... Tchaikovsky was a homosexual ... truth be told we don't love him because of its ... but he was a great musician ... Carrasco comes to a CD of former US president ... says he once looked into Mr Putin's eyes and was able to get a sense of his soul ... president George W Bush Rice she got the Sands Mr. ping was unimpressed ... by the need to Bush's dog ... introducing Mr Bush to his big black Labrador Mr. Patten said ... bigger stronger and faster than Barney ... when Mr. Bushnell distorted Prime Minister Stephen