I noticed I see this deleted branch when I do git branch -a on my laptop. The way you delete the remote branch from your local list of remote branches is with this:

git branch -rd origin/branchname

References:

http://help.github.com/remotes/

Register this dll on your build machine as:

regsvr32 msdia100.dll

Stack at the exception:

Phx.FatalError
Exception of type 'Phx.FatalError' was thrown.
at Phx.FatalError.Dispatch()
at Phx.Logging.Diagnostics.DiagnosticMessage.LogMessage(Severity severity, DiagnosticInfo diagnosticInfo, SourceContext sourceContext, String descriptionString)
at Phx.PE.PEUtilities.UserError(String infoMessage)
at Phx.Pdb.ReaderImplementation.Open(Boolean loadTypeOnly)
at Phx.PEModuleUnit.LoadPdb()
at Phx.PE.ReaderPhase.CheckSymbolicInformation()
at Phx.PEModuleUnit.LoadGlobalSymbols()
at Phx.PEModuleUnit.LoadEncodedIRUnitList()
at Phx.PEModuleUnit.GetEnumerableContributionUnit()
at Microsoft.FxCop.Engines.Phoenix.PreScanPass.GetFunctionUnits(PEModuleUnit peModuleUnit)
at Microsoft.FxCop.Engines.Phoenix.PreScanPass.Execute(ModuleUnit moduleUnit)
at Phx.Passes.PassList.DoPassList(ModuleUnit moduleUnit)
at Microsoft.FxCop.Engines.Phoenix.PhoenixAnalysisEngine.AnalyzeInternal()
at Microsoft.FxCop.Engines.Phoenix.PhoenixAnalysisEngine.Analyze()
at Microsoft.FxCop.Common.EngineManager.Analyze(Project project, Boolean verboseOutput)

On the Windows Server:

• Install git (http://code.google.com/p/msysgit)
• Create and share a folder where you will use it as central repository (C:\repositories\myproject). Setup whatever permissions you want to setup on the shared folder.
• Run git bash and:

cd myproject
git init --bare

On your Windows Workstation

• Map the shared folder (mypoject) on the server to a drive (ie: z) on your workstation
• Install git (http://code.google.com/p/msysgit)
• Create a folder where you will work on the project.
• Run git bash and:

cd /c/projects
mkdir myproject
cd myproject
git init
touch readme.txt
notepad readme.txt # add some content
git add -A
git commit -m 'initial checkin'
git remote add origin file:///z/repositories/myproject
git push origin master
git branch -a


This is it…

• Part 1
• Part 2
• Part 3

There are few things I’d like to do to evolve the repositories.

• Use Linq for specifications
• Introduce Unit of Work (UoW)

Linq for specifications

I used specification objects to build specifications to create query criterion previously. I had to use specification objects to describe the criteria. This may be OK but when the number of criterion increases, management of these specification classes will be an overhead.

We can use Linq and Expressions in favor of our own explicit specifications. Given the popularity and acceptance of Linq, your data store will most likely support Linq in its API so your expressions in your criteria will play nicely.

I like to first separate the query and update portions of the repository. This allows us to be granular. Separating commands and queries from the repository gives me flexibility. I can inject query into controllers which does nothing but querying the data store and building a view model. I can send commands to a message bus and handler of that command can depend on the IUpdateModel contract to persist. The query side may even be in the cache. This is a way to enable CQS (Command Query Seperation) in your domain.

I made the repository non generic and added type parameters to its methods. This makes injecting repositories easier into dependent components.

There is a linq specifications project at google code if like to use a linq based specification for the previously discussed explicit specification solution in part 3.

Unit Of Work

There are lots of materials you can find on the subject. Here are some links to get started…

• Martin Fowler
• MSDN article from Jeremy Miller
• Implementing Unit of Work with Entity Framework

One think you should be aware is that most data access tools you use (NHibernate, Linq To Sql, Entity Framwork, etc…) already utilize the unit of work pattern. NHibernate uses ISession and the latter two uses DataContext. They are all “units of work” which tracks changes to entities within its scope.

In this example, I used entity framework for persistence. The domain repository will be using that. The unit of work implementation follows the domain below.

public interface IQueryModel
{
	TEntity Get<TEntity>(Func<TEntity, bool> where) where TEntity : class;
	IEnumerable<TEntity> GetMany<TEntity>(Func<TEntity, bool> where) where TEntity : class;
	IEnumerable<TEntity> GetAll<TEntity>() where TEntity : class;
}

public interface IUpdateModel
{
	void Save<TEntity>(TEntity dto) where TEntity : class;
	void Update<TEntity>(TEntity entity) where TEntity : class;
	void Delete<TEntity>(Func<TEntity, bool> predicate) where TEntity : class;
	void Delete<TEntity>(TEntity entity) where TEntity : class;
}

public interface IRepository : IQueryModel, IUpdateModel
{
}

public interface IPersistData
{
	void Persist();
	IPersistData New();
}

// Entity framework dependent data persister
public class EfDataContext : DbContext, IPersistData
{
	public DbSet<User> Users { get; set; }

	public EfDataContext()
		: base("RepositorySeries")
	{
	}

	#region Implementation of IPersistData

	public void Persist()
	{
		SaveChanges();
	}

	public IPersistData New()
	{
		return new EfDataContext();
	}

	#endregion
}

// simple entity
public class User
{
	[Key]
	public int UserID { get; set; }
	public string FullName { get; set; }
}

// Entity framework dependent repository
public class DomainRepository : IRepository
{
	private DbContext m_db;

	public DomainRepository(DbContext db)
	{
		m_db = db;
	}
	public DomainRepository()
	{
		m_db = new EfDataContext();
	}

	#region Implementation of IQueryModel

	public TEntity Get<TEntity>(Func<TEntity, bool> where) where TEntity : class
	{
		return m_db.Set<TEntity>().FirstOrDefault(where);
	}

	public IEnumerable<TEntity> GetMany<TEntity>(Func<TEntity, bool> where) where TEntity : class
	{
		return m_db.Set<TEntity>().Where(where);
	}

	public IEnumerable<TEntity> GetAll<TEntity>() where TEntity : class
	{
		return m_db.Set<TEntity>();
	}

	#endregion

	#region Implementation of IUpdateModel

	public void Save<TEntity>(TEntity dto) where TEntity : class
	{
		m_db.Set<TEntity>().Add(dto);
	}

	public void Update<TEntity>(TEntity entity) where TEntity : class
	{
		m_db.Entry(entity).State = EntityState.Modified;
	}

	public void Delete<TEntity>(Func<TEntity, bool> predicate) where TEntity : class
	{
		var entity = m_db.Set<TEntity>().FirstOrDefault(predicate);

		m_db.Set<TEntity>().Remove(entity);
	}

	public void Delete<TEntity>(TEntity entity) where TEntity : class
	{
		m_db.Set<TEntity>().Remove(entity);
	}

	#endregion

	#region Implementation of IRepository

	public void Commit()
	{
		m_db.SaveChanges();
	}

	public void Rollback()
	{
		m_db = new EfDataContext();
	}

	#endregion
}

public interface IUnitOfWork
{
	IRepository Repository { get; }
	void Commit();
	void Rollback();
}

public class UnitOfWork : IUnitOfWork
{
	private IPersistData m_db;

	public UnitOfWork(IRepository repository, IPersistData db)
	{
		m_db = db;
		Repository = repository;
	}

	#region Implementation of IUnitOfWork

	public IRepository Repository { get; private set; }

	public void Commit()
	{
		try
		{
			m_db.Persist();
		}
		catch (Exception ex)
		{
			Rollback();

			throw ex;
		}
	}

	public void Rollback()
	{
		m_db = m_db.New();
	}

	#endregion
}

// sample app using all above
class Program
{
	static void Main(string[] args)
	{
		// get these from container (DI)
		IRepository repository = new DomainRepository();
		IPersistData db = new EfDataContext();

		// unit of work object
		var uow = new UnitOfWork(repository, db);

		// sample entity
		var u1 = new User { FullName = "Homer Simpson", };

		// add, edit, delete entities on the repository
		uow.Repository.Save(u1);

		// commit changes in unit of work
		uow.Commit();
	}
}

The interfaces and unit of work implementation does not have any dependency to a data access technology. DomainRepository and EfDataContext have dependencies to Entity Framework in this case. This implementation can be changed to some other data access technology easily.

http://fernandotakai.wordpress.com/2008/06/17/adding-autocomplete-to-a-python-console/

• git add -A stages All
• git add . stages new and modified, without deleted
• git add -u stages modified and updated, without new

http://help.github.com/git-cheat-sheets/

sudo add-apt-repository ppa:jerome-etienne/neoip
sudo apt-get update && sudo apt-get install nodejs

rails c

Issue was with readline and ncurses libraries. Go to

~/.rvm/src/ruby-1.9.2-p0/ext/readline
ruby extconf.rb
make
make install

That should do it…

sudo vim etc/apt/sources.list
deb http://download.webmin.com/download/repository sarge contrib
wget http://www.webmin.com/jcameron-key.asc
sudo apt-key add jcameron-key.asc
apt-get update
apt-get install webmin
https://localhost:10000

• Collocation - A collocation is a sequence of words that occur together unusually often. Thus red wine is a collocation, whereas the wine is not. A characteristic of collocations is that they are resistant to substitution with words that have similar senses; for example, maroon wine sounds very odd.
• Bigram – Word pairs; such as “red wine“.
• Corpus (plural corpora) or text corpus is a large and structured set of texts (now usually electronically stored and processed). They are used to do statistical analysis and hypothesis testing, checking occurrences or validating linguistic rules on a specific universe.
• Entropy is a measure of the uncertainty associated with a random variable. The term by itself in this context usually refers to the Shannon entropy. Shannon entropy is a measure of disorder, or more precisely unpredictability. For example, a series of coin tosses with a fair coin has maximum entropy, since there is no way to predict what will come next. A string of coin tosses with a two-headed coin has zero entropy, since the coin will always come up heads. Most collections of data in the real world lie somewhere in between.
• Maximum Entropy Modelling – General-purpose machine learning technique. When characterizing some unknown events with a statistical model, we should always choose the one that has Maximum Entropy. Maximum entropy modeling is a general-purpose machine learning technique originally developed for statistical physics, but which has been employed in a wide variety of fields, including computer vision and natural language processing. It can be usefully applied whenever there is a complex process whose internals are unknown but which must be modeled by the computer. Like any statistical modeling technique, it relies on the existence of a data sample that shows, for given sets of input, what output the process generates. This sample is analysed, and from it, a model is generated, encapsulating all the rules about the process that could be inferred from the sample. This model is then used to predict the output of the process, when supplied with sets of input not found in the sample data. (Presentation)
• Conditional Frequency Distribution – Collection of frequency distributions, each one for a different “condition.” The condition will often be the category of the text. A frequency distribution counts observable events, such as the appearance of words ina text. A conditional frequency distribution needs to pair each event with a condition.
• Semantic Network – Represents semantic relations among concepts. This is often used as a form of knowledge representation. It is a directed or undirected graph consisting of vertices, which represent concepts, and edges.
• Language Resource – Refers to data-only resources such as lexicons, corpora, thesauri or ontologies.
• Morpheme – The smallest component of word, or other linguistic unit, that has semantic meaning. The term is used as part of the branch of linguistics known as morpheme-based morphology. A morpheme is composed by phoneme(s) (the smallest linguistically distinctive units of sound) in spoken language, and by grapheme(s) (the smallest units of written language) in written language.
• Ontology – Formal representation of a set of concepts within a domain and the relationships between those concepts. It is used to reason about the properties of that domain, and may be used to define the domain.
• Anaphora - Instance of an expression referring to another. The monkey took the banana and ate it. “It” is anaphoric under the strict definition (it refers to the banana).
• Lexicon of a language is its vocabulary, including its words and expressions.
• Lexeme is an abstract unit of morphological analysis in linguistics, that roughly corresponds to a set of forms taken by a single word. For example, in the English language, run, runs, ran and running are forms of the same lexeme, conventionally written as run.
• Lemma is the canonical form of a lexeme. Lexeme, in this context, refers to the set of all the forms that have the same meaning, and lemma refers to the particular form that is chosen by convention to represent the lexeme.
• Coreference – It occurs when multiple expressions in a sentence or document refer to the same thing; or in linguistic jargon, they have the same “referent.” For example, in the sentence “Mary said she would help me”, “she” and “Mary” are most likely referring to the same person or group, in which case they are coreferent. Similarly, in “I saw Scott yesterday. He was fishing by the lake,” Scott and he are most likely coreferent.
• POS Tagging – The process of classifying words into their parts-of-speech and labeling them accordingly is known as part-of-speech tagging, POS tagging, or simply tagging. Parts-of-speech are also known as word classes or lexical categories. The collection of tagsused for a particular task is known as a tagset.

• tf–idf weight (term frequency–inverse document frequency) is a weight often used in information retrieval and text mining. This weight is a statistical measure used to evaluate how important a word is to a document in a collection or corpus. The importance increases proportionally to the number of times a word appears in the document but is offset by the frequency of the word in the corpus. Variations of the tf–idf weighting scheme are often used by search engines as a central tool in scoring and ranking a document’s relevance given a user query. One of the simplest ranking functions is computed by summing the tf-idf for each query term; many more sophisticated ranking functions are variants of this simple model.

I will be updating this list as I encounter them…