c:\cmdauto.cmd
@echo off
doskey cd=pushd $*
Since you've been using ZFS-fuse for a time now, can you report here or blog about its stability? Has the daemon crashed on you, while taking a snapshot, or while "scrub"-ing?
How much data have you passed in?
NAME USED AVAIL REFER MOUNTPOINT nas-pool 352G 105G 24K /nas-pool nas-pool/archive 118G 105G 71.1G /nas-pool/archive nas-pool/bulk 234G 105G 228G /nas-pool/bulk
But everything thus far shows us that perpetual growth is possible. Technology is a wonderful thing - each year we're able to do more with less.
That's not to say that a lot of what goes on in the market isn't pure, unadulterated bullshit, but real, honest-to-goodness "growth" won't stop until technology does.
This is a textbook example of the "cornucopian" view on economics. The implicit assumption here is that there are no limits to technological improvements, or that those limits are extremely far in our future. I think that this assumption is flat out wrong and dangerous. It is these sorts of ideas which have lead large parts of the global economy to eerily resemble Ponzi Schemes.
I wrote the following post in reply:
There are limits to exponential growth. (And make no mistake, growth expressed as a fixed percentage per year is exponential). Technology can push the limits closer to what the laws of physics allow, but technology cannot change the laws of physics.
Let's look at some numbers to drive the point home. Our global energy consumption in 2008 was estimated to be 474 exajoules.
The total energy received by the earth from the sun during a year is about 5 million exajoules, a fraction of which reaches the surface. 5 million is much more than 474. But at a seemingly modest 2% per year growth rate (as it was between 1980 and 2006), our energy consumption will match those 5 million exajoules in less than 500 years!
Think about that: if energy consumption growth continues at the current pace, then in 500 years we'll either be using ALL solar energy received by the earth (leaving none for the biosphere), or we'll have figured out some magic technology to produce 5 million exajoules of energy per year. Assuming the magic technology, where are we going to get rid of all that extra heat? It would effectively be like having a second sun on earth, cooking us in place.
Granted, you did say "do more with less". So lets say energy consumption will stay constant in the future, and instead we'll derive 2% more "value" from the same energy each year. Now you run into a new problem. No matter how you define "value", you run into physical limits. If you define value as "amount of mass lifted out of the earth's gravity field", then the hard efficiency limit is a minimum of 60 megajoules per kg. If you define value as "amount of computation", then again there are limits given by the laws of physics.
Exponential growth is counterintuitive. No matter how far you push the limits (e.g. by colonizing the entire galaxy or inventing game-changing technology), exponential growth will hit its limits much faster than you think. We're talking about growth with a fixed doubling period here.
Finally, I'd argue that we are already experiencing the end of exponential growth today. After decades of growth, in 2004 global oil production reached a plateau [theoildrum.com]. It's not a coincidence that we experienced a major financial crash and recession soon after that. The era of "perpetual growth" is over. The next era will be that of the "zero-sum game" at best.
On a related note, after writing the above post I stumbled on this excellent series of videos of a lecture by Dr. Albert A. Bartlett where he shows with some very simple calculations and examples that "steady growth" is in fact always unsustainable. We have to find a way to get our civilization to work with 0% growth. The alternative is total collapse, probably within decades.
var container = new Container(); container.Bind<App, App>(); container.Bind<IFoo, Foo>(); container.Bind<IBar, Bar>(); var app = container.Pull<App>(); app.Run();
public class Container
{
private readonly Dictionary<Type, Type> contractToClassMap = new Dictionary<Type, Type>();
private readonly Dictionary<Type, object> contractToInstanceMap = new Dictionary<Type, object>();
public void Bind<TContract, TClass>() where TClass : class, TContract
{
this.contractToClassMap[typeof(TContract)] = typeof(TClass);
}
public TContract Pull<TContract>()
{
return (TContract)Pull(typeof(TContract));
}
public object Pull(Type contract)
{
object instance;
this.contractToInstanceMap.TryGetValue(contract, out instance);
if (instance == null)
{
var constructor = contractToClassMap[contract].GetConstructors()[0];
var args =
from parameter in constructor.GetParameters()
select Pull(parameter.ParameterType);
instance = constructor.Invoke(args.ToArray());
this.contractToInstanceMap[contract] = instance;
}
return instance;
}
}
public abstract class ViewModelBase : INotifyPropertyChanged
{
protected virtual void OnPropertyChanged(string propertyName)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
public event PropertyChangedEventHandler PropertyChanged;
}
Foo foo = new Foo();
string propertyName = GetPropertyNameFromExpression<Foo,int>(x => x.Bar);
Debug.Assert(propertyName == "Bar");
private string GetPropertyNameFromExpression<TClass,TProperty>(
Expression<Func<TClass, TProperty>> expression)
{
var memberExpression = expression.Body as MemberExpression;
if (memberExpression == null)
throw new ArgumentException(String.Format(
"'{0}' is not a member expression", expression.Body));
return memberExpression.Member.Name;
}
public abstract class ViewModelBase<TDerived> : INotifyPropertyChanged
where TDerived : ViewModelBase<TDerived>
{
private string GetPropertyNameFromExpression<TPropertyType>(
Expression<Func<TDerived, TPropertyType>> expression)
{
var memberExpression = expression.Body as MemberExpression;
if (memberExpression == null)
throw new ArgumentException(String.Format(
"'{0}' is not a member expression", expression.Body));
return memberExpression.Member.Name;
}
/// <summary>
/// Triggers the <see cref="PropertyChanged"/> event for the property used in
/// <paramref name="expression"/>
/// </summary>
/// <param name="expression">
/// A simple member expression which uses the property to trigger the event for, e.g.
/// <c>x => x.Foo</c> will raise the event for the property "Foo".
/// </param>
protected void OnPropertyChanged<TPropertyType>(
Expression<Func<TDerived,TPropertyType>> expression)
{
string name = GetPropertyNameFromExpression(expression);
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(name));
}
public event PropertyChangedEventHandler PropertyChanged;
}
public class FooViewModel : ViewModelBase<FooViewModel>
{
private int bar;
public int Bar
{
get
{
return this.bar;
}
set
{
this.bar = value;
OnPropertyChanged(x => x.Bar);
}
}
}
Does the GPL require that source code of modified versions be posted to the public?
The GPL does not require you to release your modified version, or any part of it. You are free to make modifications and use them privately, without ever releasing them. This applies to organizations (including companies), too; an organization can make a modified version and use it
internally without ever releasing it outside the organization.
But if you release the modified version to the public in some way, the GPL requires you to make the modified source code available to the program'susers, under the GPL.
Thus, the GPL gives permission to release the modified program in certain ways, and not in other ways; but the decision of whether to release it is up to you.