String Searching – The Knuth-Morris-Pratt Algorithm

We’ve seen how to do the naive approach towards pattern matching. So what about other algorithms that are much more better at doing this task? This is the Knuth-Morris-Pratt (KMP) algorithm for pattern matching.

String Searching – The Naive Approach

We all should all know what string searching is. We have a pattern p and some string s, and we wish to see if p exists in s. There are a number of ways to do this, and this is one of those many ways; the naive approach.

Computer Vision – The Integral Image

The Integral Image or Summed Area Table, was first introduced to us in 1984, but wasn't properly introduced to the world of Computer Vision till 2001 by Viola and Jones with the Viola-Jones Object Detection Framework.

The Integral Imagine is used as a quick and effective way of calculating the sum of values (pixel values) in a given imagine – or a rectangular subset of a grid (the given imagine).

It can also, or is mainly, used for calculating the average intensity within a given imagine. If one wants to use the Integral Image, it is normally a wise idea to make sure the image is in greyscale first.

Software Engineering - Summary

I didn't make these, but Nida has kindly made a summary for software engineering and asked me to publish it, so here it is!

Symbolic AI – Deep and Surface Structure Trees

Finally, you get to see a tree :D

This post will cover the basics of what Deep and Surface Structure trees are, as well as a little bit on moved words – only little though!

Symbolic AI – Basic Lambda Calculus 2

This is the second part to the Basic Lambda Calculus 1. In this we’ll go through a proper example.

Symbolic AI – Basic Lambda Calculus 1

This post will explain some of the basics of Lambda Calculus, mainly Alpha-Conversion and Beta-Reduction. We’ll also see a quick example of a simple sentence.

This post is being written with me being slightly ill… so some bits may make no sense whatsoever – sorry :(

Nida’s Awesome Distributed Systems Notes

Hi everyone,

My name's Nida and I wrote some really awesome notes that James even uploaded to his webspace for me - but I forgot to put the link on the blog! Gah! Silly me!

Here's the link to them.

ACID

This is going to be a very quick post, mainly because so many people have asked me what ACID means.

This post applies to a lot of topics / modules; but mainly to Databases and Distributed Computing.

Representation State Transfer - REST

Now for the final section about these architectures. This post will cover the aspects concerning the REST Architecture. It really simple to grasp the concept of it, so lets take a look!

Distributed Computing – SOAP

No, this post is not about the slippery block of nice smelling soap! SOAP in Distributed Computing is another form of message exchanging between peers, and here we describe how it does this.

Service Oriented Architecture – Part (2/2)

This is the second part to SOA’s, in this post we’ll have a look at Message-Oriented Middleware (MOM’s) and other various things to finish of this section.

Service Oriented Architecture – Part (1/2)

Over the next – possibly – 2 or 3 posts, i am going to be posting about SOA, Services and MOM’s. Then they’ll be a post about SOAP, then finally one about REST. All of which are Architectures for Computing in their own right.

However, this post will mark the start – explaining in detail what SOA really is, what a Service is, as well as MOM’s (i will try a reframe from ‘ya mom’ jokes)  :)

Algorithms – The 0/1 Knapsack Problem – Dynamic Programming method

Okay, I didn't see that James had made a video about the very same subject. Great minds think alike I guess? Sigh. Well, here it is: The Dynamic Programming method for solving a 0/1 Knapsack Problem explained, in depth, by me in under 11 minutes!



Bug 1: Ignore the "The cell with the green circle around has a capacity of" blah blah etc. because I uploaded the wrong version ._. The green circle should be around cell (3,1).
Bug 2: I circle item '1' when I should circle item '3' at the end when we're going through the keep array. I fail.
Bug 3: I say '2' somewhere instead of '3'. See if you can spot it.

Sorting – Quick Sort

A post dedicated to that oh so famous, Quick sort! ^^

Sorting – Merge Sort

A post all about the Merge sort :D

Shortest Path – Dijkstra’s Algorithm

We’ve all used those horrible SATNAV’s to get from one place to another. But how do they calculate the path we must follow in order to minimize the time needed.

This is a shortest distance problem, which shall be covered in this post via Dijkstra’s Algorithm.

Algorithms – Quick Graph Terminology

This post will be brief. It just contains a load of terminology for parts of graphs, such as:

• Spanning Trees
• Back Edges
• etc…

Algorithms – Depth/Breadth First Search

We have seen some of the key concepts to Graphs; What a node is, an edge – as well as definitions for Digraphs and Undirected Graphs – and other bits ‘n’ bobs :) .

But one question stills looms; How do we traverse a Graph?

Here we shall look at two of the key traversing algorithms for Graphs:

• Depth First Search (DFS), and
• Breadth First Search (BFS).

Algorithms – Adjacency Lists and Matrices

Nodes can be connected to other nodes – otherwise it would be a bleeding useless graph! :D

But how do we know which node is connected to which nodes? Welcome to the wonderful world of Adjacency Lists and Matrices!

Also, i apologise for the long pause in posts! :(