Eternity Belongs to Science

ADB doesn't recognize my Android Phone under Mac OS X 10.6.x

2011-10-02T15:10:00.001+03:00

In numerous forums and even more in www.stackoverflow.com are posted unresolved questions regarding ADB's luck of device recognition under Mac OS X 10.6.x. After facing the same problem with my Nexus S I start experimenting.

I noticed that indeed ADB weren't listed my device with the ./adb devices command.

$ ./adb devices

Though, system profiler.app was successfully listing my phone, as other services such as tethering and fastboot ( fastboot:Yes I tried Everything..!! ). Moreover, reinstalls and restarts of adb server was also a drop to space. So that made me curious regarding this as the same phone was working under Linux and Windows systems and also tethering was a succes under Mac OS X.

The answer was simple, the service of tethering that was running in my Mac was blocking ADB server to communicate with the device, so the listing was a failure.

So in simple steps, before you plug-in your device for debugging purposes you should first unload the EasyTetherUSBEthernet service. You may achieve that by submitting this command to your terminal:

$ sudo kextunload /System/Library/Extensions/EasyTetherUSBEthernet.kext

Then plug-in your device and then submit the known-unknow command, by first having changed your directory to the android-sdk/tools folder

$ ./adb devices

or just

$ adb devices

in case you have set the android-sdk to you environment profile. If you didn't then you should! Just under your Home directory locate the .bash_profile file and at the PATH variable add the android-sdk/tools directory.

Furthermore, in case you wish to reload the EasyTetherUSBEthernet service just submit this:

$ sudo kextload /System/Library/Extensions/EasyTetherUSBEthernet.kext

And in any case wanting to remove the EasyTetherUSBEthernet submit ( witch I don't Recommend)

$ sudo kextunload /System/Library/Extensions/EasyTetherUSBEthernet.kext

$ sudo rm -rf /System/Library/Extensions/EasyTetherUSBEthernet.kext

That's all folks, I hope you enjoy it as much it helped you. :)

Thanks for reading it!

Quantum computing with light

2011-09-10T12:00:00.001+03:00

A switch that lets one photon alter the quantum state of another could point the way to both practical quantum computers and a quantum Internet.

Larry Hardesty, MIT News Office - SOURCE

Quantum computers are largely theoretical devices that would exploit the weird properties of matter at extremely small scales to perform calculations, in some cases much more rapidly than conventional computers can. To date, the most promising approach to building quantum computers has been to use ions trapped in electric fields. Using photons instead would have many advantages, but it's notoriously difficult to get photons to interact: Two photons that collide in a vacuum simply pass through each other.

In Science, researchers at the Massachusetts Institute of Technology (MIT) and Harvard Universitydescribe an experiment that allows a single photon to control the quantum state of another photon. The result could have wide-ranging consequences for quantum computing and quantum communication, the quantum analog to conventional telecommunications.

A quantum particle has the odd property that it can be in "superposition," meaning it's in two different states at the same time: Fire a single photon at a barrier with two slits in it, for instance, and it will, in some sense, pass through both of them. Where the bits in an ordinary computer can represent either zero or one, a bit made from a qubit could thus represent both zero and one at the same time.

For this reason, a string of only 16 qubits could represent 64,000 different numbers simultaneously. It's because a quantum computer could, in principle, evaluate possible solutions to the same problem in parallel that quantum computing promises major increases in computational speed.

But one of the difficulties in building quantum computers is that superpositions of states can be very fragile: Any interaction with its environment can cause a subatomic particle to snap into just one of its possible states. Photons are much more resistant to outside influences than subatomic particles, but that also makes them harder to control; over the course of a computation, a quantum computer needs to repeatedly alter the states of qubits.

The MIT and Harvard researchers' new paper points toward a quantum computer that offers the best of both worlds: stability and control. Moreover, photons in superposition could carry information stored as qubits rather than as ordinary bits, opening the possibility of a quantum Internet.

Slowing light
Vladan Vuletic, the Lester Wolfe Professor of Physics at MIT; his student, Haruka Tanji-Suzuki, a member of the MIT-Harvard Center for Ultracold Atoms (CUA); Wenlan Chen, an MIT graduate student, and Renate Landig, a visiting student, both at CUA; and Jonathan Simon, a postdoc at Harvard, developed an optical switch that consists of a small cluster of cesium atoms suspended between two tiny mirrors in a vacuum cavity. "The only way to make two photons interact with one another is to use atoms as a mediator," Vuletic says. "The [first] photon changes the state of the atom, and therefore it modifies the atom’s interaction with the other photon."

When a photon enters the cavity, it begins bouncing back and forth between the mirrors, delaying its emission on the other side. If another photon has already struck the cesium atoms, then each pass through them delays this second photon even more. The delay induced by a single pass through the atoms would be imperceptible, but the mirror-lined cavity, Vuletic explains, "allows us to pass the photon many, many times through the atoms. In our case, it’s like passing the photon 40,000 times through the atoms."

When it emerges from the cavity, the second photon thus has two possible states—delayed or extra-delayed—depending on whether another photon has preceded it. With these two states, it could, in principle, represent a bit of information. And if the first photon was in some weird quantum state, where it can't be said to have struck the atoms or not, the second photon will be both extra-delayed and not extra-delayed at the same time. The cavity would thus serve as a quantum switch, the fundamental building block of a quantum computer.

Counting photons
Currently, the extra delay is not quite long enough that delayed and extra-delayed photons can be entirely distinguished, but if the researchers can increase its duration, the switch could have other uses as well. Many potential applications of quantum optics, such as quantum cryptography, quantum communication, and quantum-enhanced imaging, require photons that are emitted in definite numbers—usually one or two. But the most practical method of emitting small numbers of photons—a very weak laser—can promise only an average of one photon at a time: There might sometimes be two, or three, or none. The CUA researchers' switch could be tailored to separate photons into groups of one, two, or three and route them onto different paths.

Because the switch allows the state of one photon to determine that of another, it could also serve as an amplifier in a quantum Internet, increasing the strength of an optical signal without knocking the individual photons out of superposition. By the same token, it could serve as a probe that detects photons without knocking them out of superposition, improving the efficiency of quantum computation.

Why Golden Ratio Matter's Computer Science

2011-09-06T22:24:00.002+03:00

Author: Evangelos Pappas – evalon.gr

Golden ratio is a mathematic constant that is often used to describe the perfect symmetry. This value is being implemented in a various ways and sciences. It is inspired by nature and so it creates the illusion of the beauty. Though it is scientific improved computer scientist has barely implement this ratio, and when its done it doesn’t follows exactly the symmetry as it should. As it follows this theory will be barely described as an implementation in a web application. At this point it should be mentioned that the pages that follows are not a tutorial rather than an article.

Introduction

As a Scientist fetish I love mathematics. Maybe I'm not a Mathematician or a Physicist, though mathematics has found numerous applications in Computer Science. As mathematics are all around us as computer algorithms are also. Problems in every day life can be described in an algorithmic way resulting a more optimized way of achieving them.

Now what is the golden ratio and what does it have to do with all this science? The answer is simple. This number, which is represented by the Greek letter Phi (Φ), has inspire nature in many ways such as biology, mechanics and architecture. It basically represents the perfect symmetry in many ways. That symmetry results the beauty or as I like to call it “beauty Simplicity”, it achieves its beauty by simple generating symmetric descendants.

I have seen this number’s value applications variant from 1.61 to 1.63 though its accepted form is at ~1.618. Moreover, Golden ratio is usually messed with Fibonacci’s sequence. This sequence should be already known to most of you, though if you haven’t heard of this ( then you must be at the first year of B.Sc. of CS or a non-related-computer-scientist at all J ) then go to Wikipedia article which cover it pretty well.

Figure 1 This equation explains how the golden ratio is resulted by the generation of the new element which depends from its previous (from Wikipedia)

Matters, Web

Web designing & developing maybe is one of the most fancy arcitectuall designing applications of Computer Science. Such applications that affect the most User’s Interaction and browsing. So the most critical part of these applications is the best architectuall design in order to be eye friendly and fast browsing.

I have been thinking and found that the best way to achieve somthing like that (a user & eye friendly enviroment) should mimic the nature. As nature is the most human friendly enviroment so computer applications should be.

Now, enough with the much talk! How this could be implemented. The answer is still simple. It is already implemented. Many web-site aproach this implementation at its most of its percentance without knowing it. Though there were no theory explaining it why does this happen. Watch this layout:

Figure 2 a simple example of web page layout that follows the described theory

By viewing this schema, its obvious the size’s expansion of each element comparing it with their near elements. By assuming that the “title” element is being divided in two, the next element, the “logo” has expand its both width & height size by the Golden ration.

A great schema that describes my theory is being publish at Wikipedia :

Figure 3 a Shape representation of Fibonacci sequence. Shows aligned rectangles expanding their size according to the golden ratio

Matters, edges

There is a trend in recent web developments that has expanded and inspires the web development community. I am referring to the edge rounding. A great example of what I am referring to is being described here: http://www.css3.info/preview/rounded-border/

As we, humans are used to like rounded things so in a Graphic environment in our computer we would like too. Imagining in the schema above ( figure 3 ) a string line that is drew from the corners of each rectangle then a snail shell like schema will be figured.

This new figure will follow the principles of the golden spiral or as most known as Logarithmic spiral.

Figure 4 The golden Spiral

In web developing, in order to implement this in a block element we have to set its style. In order to keep the symmetry of our layout the “em” scalable unit will be used. “Em” unit generates the size of the described element according to the already set size of the inherited elements. So if we have set in our div a font size to 12px the 1em sets the size to the character to 12px.

The code that implements this rule to a block element follows:

webkit-border-radius: 0.81em 1.61em 2.59em 4.17em;

-moz-border-radius: 0.81em 1.61em 2.59em 4.17em;

border-radius: 0.81em 1.61em 2.59em 4.17em;

Conclusion

This theory should not be mentioned as radical rather than a notice to Computer Scientists. It does not prove something new or not even developed something really innovated. It just proposes a better statured layout that follows principles and theories of mathematics.

Thank you very much for your interest and reading :) .

Tip: C\C++ Logical Error on Division

2011-08-22T23:11:00.001+03:00

Logical errors are the worst nightmare, even for a senior programmer. As experience is gained such issues are getting more and more familiar to recognize and avoid them. Though tips should be always welcomed, especially for the newcomers.

Enough with the much talk! take good look at this:

void main() { float n=0; n=7/3; printf("%f", n); }

So what the printf() you think would print?

The most of you expect something like 2.333..

Though theory is pretty strict!

Your Co. Sci. Teacher:

"You may not have a float result by dividing two integers, not even when the result is stored in a float variable."

and so you should have printed: 2

The reason of this failure lays to your integer/integer division.

So in order to achieve a float result, you should write:

void main() { float n=0; n=7.0/3.0; printf("%f", n); }

Always note:

int/int == int
float/int == float
int/float == float
float/float == float

Have fun! :)

Hopfield nets can reconstruct distorted patterns and undo noise

2011-08-02T10:42:00.001+03:00

Summary: Hopfield nets are one of the easier neural net models to understand -- and they can be useful, too. The main ability of the Hopfield net is to undo noise and reconstruct known patterns. Python programmer Andrew Blais is your guide to learning more about Hopfield nets, and exploring his net.py application.

Hot things cool, obviously. The house gets messy, frustratingly. In much the same way, messages are distorted. Short-term strategies for reversing these things include, respectively, reheating, cleaning, and the Hopfield net. This article introduces you to the last of these three, an algorithm that can, within certain parameters, undo noise. A very simple Python implementation, net.py, will show you how its basic parts fit together, and why a Hopfield net can sometimes retrieve a pattern from its distortion. This implementation, while limited, will still enable you to perform a number of instructive and revealing experiments on the Hopfield net.

What is your quest?

I assume that you are reading this because you have some computational problem. You have been advised that some neural net algorithm might provide a solution. Specifically, the suggestion is that you might employ a Hopfield net. I suppose further that you need a precis of the idea so you can decide whether the suggestion is feasible and warrants more exploration. The following broadly sketched application of the Hopfield net may get you started solving your problem.

Your problem begins with a base set of patterns that are encoded with -1s and +1s. They can be encoded in 0s and +1s, if necessary. These patterns could be normalized binary images of postage stamps (see Resources). The next element is a set of patterns that deviate from this base. Your quest is to create code that inputs a deviant pattern and outputs just one base pattern. Your quest then would be an algorithm that can input an encoded representation of a particular stamp, and output just one base stamp pattern. You're not searching for certainty. There is an acceptable failure rate that does not adversely affect your enterprise. For you, there is a rate at which stamps can be misrecognized that doesn't significantly interfere with your project.

If this reminds you of your problem, the following might be the beginning of the development of your solution. By the end, you should be better able to answer the basic questions. What is this Hopfield thing? How does it work? What are its limitations? What can it do for me? Do I want to spend more time investigating this?

Patterns and their distortion

Let's begin with five arbitrary patterns patterns that will be distorted and subsequently retrieved. Visually, they can be represented as ten-by-ten matrices of black and white squares. Figure 1 shows the first pattern, p1.

Figure 1. Visual representation of p1

Clicking on any of p2 through p5 in net.py displays the other patterns. For coding purposes, these five patterns are initially represented as Python lists. So, the first pattern, for example, is represented in Listing 1.

Listing 1. Pattern p1

p1 = [ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1], [-1, -1, -1, -1, -1, -1, -1, -1, 1, 1] ]

Black and white squares correspond to -1 and +1, respectively. Such a list is subsequently converted into an array. (SeeResources for references to the Python libraries that I utilized.) For each element in such a pattern, a -1 or +1, there is a node object in an array of nodes.

A node object has three central attributes:

A node object has a value that is an element in the pattern.
A node also has an address, that is, the address of its position in an array.
Each node also has a color that makes it possible to display it.

As noted, one function of a Hopfield net is to undo noise. To implement this, there needs to be a way to introduce patter into a pattern. Clicking Add Noise does precisely this. Adding noise to p1 produced Figure 2.

Figure 2. A distortion of p1

To introduce noise into a pattern, the Hopfield net visits each address in the array of nodes. It then picks a random number in [0,1), that is, in the interval from zero inclusive to one exclusive. If the number is below some fixed level, the net changes the node's value and color, else it leaves it undisturbed. By default, this level is set to 0.20, and so there is a twenty percent probability that any given node will change its value and color. You can use the slider to vary this probability. At zero, there is no noise, and at one hundred, the node array is simply inverted. In between, there are all the other usual suspects. Each introduces a specific degree of noise into a pattern. Because the Hopfield net is an algorithm for undoing noise, it is able to input a distorted pattern such as the one in Figure 2 and then output its original in Figure 1.

Although sometimes obscured by bad exposition, the pertinent algorithms are fairly simple to implement. In what follows, I'll walk you through an implementation of the algorithm, and then I'll explain briefly why these algorithms can undo noise.

Weights

As David Mertz and I wrote in a previous developerWorks article, An introduction to neural nets, the human brain consists of about one hundred billion neurons, and each is, on average, connected to several thousand other neurons. Neurons both send and receive varying quantities of energy. An important feature of neurons is that they don't react immediately to the reception of energy. Instead, they sum their received energies, and they send their own quantities of energy to other neurons only when this sum has reached a certain critical threshold.

When the brain is learning, it is tempting to say that it is adjusting the number and strength of these connections. There is no doubt that this is an extreme simplification of the biological facts. Simplifications can be useful, especially when they serve as a model, in this case, for implementing cybernetic neural nets. The transition from the biological to the algorithmic is achieved by translating connections into weights. (A perceptron utilizes weights in a different and perhaps more intuitive way. Before you read on here, you might want to review An introduction to neural nets.

A weight object primarily encapsulates a numerical value that represents the weight between one node and another. A weight object also possesses an address and a color. The address is its location in the weight array. The color is for visualization. Figure 3 is one possible visual representation of a weight array. Net.py (see Resources for a link) keeps track of the lowest and greatest weights, and it will display a key to the numerical values of the colors in the weight display.

Figure 3. One visual representation of a weight array

On each row of the weight array, there is a list of all the weights between one given node and all the others. The Hopfield net has two forms. One form of node has a weight to itself, and the other doesn't. Experimenting with this via net.py shows that when nodes aren't self-weighted, node arrays don't always reconstruct to themselves. Select the No Self Weight option, and try reconstructing p3 or p5. There are one hundred nodes, and so there are ten thousand often redundant weights. When nodes are self-weighted, which is the default, then there are 5050 non-redundant weights, else there are just 4950.

Figure 4. The genesis of a weight

Listing 2. Weight generation algorithm

PAT = { x: x is a RxC pattern } WA = { x: x is a (R*C)x(R*C) weight array }  For all (i,j) and (a,b) in the range of R and C: SUM = 0 For p in PAT: SUM += p(i,j) * p(a,b) WA( (R*i)+j, (C*a)+b ) = SUM

The biologically inspired concept that underlies the Hopfield net was explored in 1949 by Donald Hebb. He conjectured that if a pair of nodes are simultaneously sending their energy to one another, then the weight between them is greater than if just one sent its energy. He wrote, "When an axon of cell A is near enough to excite B and repeatedly or persistently takes part in firing it, some growth process or metabolic change takes place in one or both cells such that A's efficiency, as one of the cells firing B, is increased" (see Resources for details). In terms of the Hopfield net, when a pair of nodes has the same value, in other words, -1 or +1, the weight between them is stronger. The sum of the products of the values of all possible node pairs determines the content of the weight array. When they are the same, their product is positive and the sum is increased. In the case of different values, this sum is decreased.

Where, more specifically, do weights come from? To begin with, the Hopfield net must have access to a library or set of basic patterns. Here, these are p1 through p5. A weight's genesis begins with the Hopfield net choosing a pair of coordinates within the bounds of a basic pattern matrix. It then visits the corresponding nodes in each pattern. At each stop, it augments an ongoing sum with the product of the values of the nodes (see Figure 4). When the net has visited each pattern, it sets the value of a weight object to this sum. Given a pair of nodes at (i,j) and (a,b), it sets the value of the weight object at (i*10+j,a*10+b) in the weight array.

That is how the array of weights is constructed, but how does it function in the larger Hopfield algorithm? How does it function in pattern reconstruction?

Reconstruction

With a weight array and a distorted or noisy pattern in hand, the Hopfield net can sometimes output the original pattern. There are no guarantees, but the net is right a surprising percent of the time. It can do this either synchronously or asynchronously.

To do this asynchronously, the net traverses the distorted pattern, and at each node, N, it asks whether N's value should be set to -1 or +1.

To ascertain this, the net traverses the row in the weight array that contains all of the weights between N and the other nodes. Keep in mind that nodes may or may not be self-weighted.

At each stop in this second traversal, it forms the product of (1) the weight between N and the other node and (2) the value of the other node. As you'd expect, the net keeps an ongoing tally of these products.

Now, the net is in a position to decide. In the present implementation at least, if this sum is less than zero, the net sets the node to -1, and if it is greater than or equal to zero, the net sets the node to +1.

Figure 5. Reconstruction: No node left behind

Listing 3. Reconstruction

For every node, N, in pattern P. SUM = 0 For every node, A, in P: W = weight between N and A V = value of A SUM += W * V if SUM < 0: set N's value to -1 else: set N's value to +1

The default update is asynchronous, because the net sets a node's value just after it decides what this value should be. It would be synchronous if the net set the values of the nodes after it had made all of its decisions. In this case, it would store its decisions, and then update the array of nodes after its last decision. In net.py (see Resources), reconstruction is, by default, asynchronous, but note the option for synchronous reconstruction.

When you experiment with net.py, and when reconstruction is successful, the Hopfield net's behavior startles. One such behavior is that even when the weight array is severely degraded, it can reconstruct patterns. My simple implementation's Degrade Weights traverses the weight array and randomly sets weights to zero. Displaying the weight array provides one view of the extent of the damage. Correct reconstruction illustrates here that a Hopfield net can be far more fault-tolerant than the brain. How does it work? The mathematical story is not short. Here instead is a plot summary.

What goes on

The algorithmic details of the Hopfield net suggest why it can sometimes undo noise. As is often true in algorithm analysis, the devil is in the mathematical details. In the present case, these are difficult to picture or imagine. There are, fortunately, some closely related phenomena whose analysis sheds light on the workings of the Hopfield net.

When a marble drops into a simply curved bowl, it rolls to the lowest point. The bowl's curvature is like a rule that inputs the marble's entry point and returns the lowest point, the bottom of the bowl. A more complicated curvature would be like a function that inputs an entry point and returns one of several local lowest points.

Energy is an essential part of these simple phenomena. In both the simple and complicated cases, the entering marble has a certain degree of energy. Over time, this energy decreases. Eventually, it reaches a stable state in which it can't diminish any further. In the complicated case, there may be a lower energy level, but the marble can't reach it.

Analogously, a pattern, distorted or not, can be thought of as having a certain degree of energy. So, patterns p1 through p5 have energy levels.

Pattern energy levels

Pattern	Energy	Rank
p1	-9600.0	1
p2	-7104.0	3
p3	-6848.0	4
p4	-9472.0	2
p5	-6408.0	5

The computation of a pattern's energy level is not complicated. For every possible pair of nodes, the Hopfield net calculates the product of their values and the weight between them. The pattern's energy level is the result of dividing the sum of these products by negative two. Net.py displays the energy level of any given pattern or node array. As you reconstruct a pattern, I expect and hope that you will see the pattern's energy level decrease.

In reconstruction, the net's decision to flip a node is based on the sum of the products of the values of the other nodes and the weights between them. When the sum is less than zero, the node is set to -1, else it is set to +1. When the product of value and weight is positive, it contributes to pushing the sum above zero. But this pushes the net in the direction of deciding to set the node's value to +1. When this product is negative, the sum is pushed to or below zero. So, the net is pushed in the direction of setting the node's value to -1. The variation in weights introduces variation into the degree to and direction in which the net is pushed in making its decision. A pattern can be so distorted that the net isn't pushed in the direction of correct decisions. Positively put, the net can be pushed to a correct decision an impressively large percent of the time.

If you reconstruct any of the five patterns, you will see that each reconstructs to itself. This is as it should be, since each pattern already occupies a local lowest energy point. There is no reconstructive process that can lower the pattern's energy level. If you succeed in reconstructing a distorted pattern, the Hopfield has reduced the pattern's energy level to the level of one of the patterns. When it fails, it has reduced the distorted pattern's energy level to a spurious local low point. In either case, the energy level cannot be reduced any further. In has, in other words, reached a stable state. Describing the Hopfield net in terms of energy has an interesting and important consequence. On this basis, it can be mathematically established that repeated application of the reconstruction algorithm will eventually result in a stable pattern. (See Resources for details.)

Summary

You should be aware of the limitations on Hopfield nets. An obvious already-cited limitation is that its patterns must be encodable in an array of either -1s and +1s, or 0s and +1s. You already know that a Hopfield can stabilize at a spurious local low. This more significant limitation is that the probability that the net will stabilize at some spurious local low increases when the number of patterns exceeds approximately 14 percent of the number of nodes in the node array. In other words, for each additional base pattern, there must be about 7 more nodes. Despite such limitations, the pattern reconstruction discussed here may serve as an illustrative guide to resolving your particular computing problem. You now have the precis of the Hopfield algorithm initially promised. Should it address your requirements, you now know the superstructure of forging your own implementations. This includes the algorithms for computing a weight array, the way to reconstruct distorted patterns, and the algorithm for computing a pattern's energy level.

Resources

Download the Net.py source code from SourceForge.
Andrew implemented the Hopfield net in Python using the Tkinter and Numeric libraries. Python lets you focus on algorithms by removing the need to focus on arcane and Byzantine syntax.
Andrew Blais and David Mertz wrote an introductory article, An introduction to neural networks (developerWorks, July 2001), that focuses on the perceptron. David W. Clark's paper of the same name includes a table comparing neural networks with digital computers. See also the Wikipedia Neural network article.
Consult Attrasoft on stamp classification and stamp recognition. For fingerprint recognition, see the design study by Nick D'Arcy. For the use of artificial intelligence in business (PDF document), see the study by Tomas Nordlander.
Neural Networks Documentation from Wolfram Research gives background on Hopfield and Hopfield nets; clicking through to Section 9.2 at the end of the document (and then clicking the Next button) leads you to an interesting discussion of using Hopfield for character recognition. Or just see the Hopfield Net entry in An Idiot's Guide to Neural Networks.
The biologically inspired concept that underlies the Hopfield net was explored in 1949 by Donald Hebb. See also The Hebb Legacy (Canadian Journal of Experimental Psychology). The study of Donald Hebb's The Organization of Behavior(Wiley, 1949) repays the required heavy lifting.
You can read JJ Hopfield's 1982 paper, Neural networks and physical systems with emergent collective computational abilities (Proceedings of the National Academy of Sciences of the United States of America, 1982) online in PDF format. You can also see what interests Professor Hopfield today.
Begin your excursion into the mathematics of the Hopfield net with these resources:
- Kevin Gurney's excellent An Introduction to Neural Networks (Routledge, 1997) focuses on building the intuitions that underlay the mathematics. See Chapter 7 for a discussion of the proof that iterated application of the reconstruction algorithm results in a stable pattern. Also see Neural Nets for an early online version.
- Neural Computing: An Introduction (Hilger, 1990), by R. Beal and T. Jackson, is also very good at developing your sense of what is going on in neural nets. In particular, see Chapter 6.

Pattern learning with the back-propagation algorithm

2011-08-02T10:38:00.001+03:00

Summary: Neural nets may be the future of computing. A good way to understand them is with a puzzle that neural nets can be used to solve. Suppose that you are given 500 characters of code that you know to be C, C++, Java, or Python. Now, construct a program that identifies the code's language. One solution is to construct a neural net that learns to identify these languages. This article discusses the basic features of neural nets and approaches to constructing them so you can apply them in your own coding.

According to a simplified account, the human brain consists of about ten billion neurons -- and a neuron is, on average, connected to several thousand other neurons. By way of these connections, neurons both send and receive varying quantities of energy. One very important feature of neurons is that they don't react immediately to the reception of energy. Instead, they sum their received energies, and they send their own quantities of energy to other neurons only when this sum has reached a certain critical threshold. The brain learns by adjusting the number and strength of these connections. Even though this picture is a simplification of the biological facts, it is sufficiently powerful to serve as a model for the neural net.

Threshold logic units (TLUs)

The first step toward understanding neural nets is to abstract from the biological neuron, and to focus on its character as athreshold logic unit (TLU). A TLU is an object that inputs an array of weighted quantities, sums them, and if this sum meets or surpasses some threshold, outputs a quantity. Let's label these features. First, there are the inputs and their weights: X₁,X₂, ..., X_nand W₁, W₂, ...,W_n. Then, there are the X_i*W_i that are summed, which yields the activation level a, in other words:

Â a = (X1 * W1)+(X2 * W2)+...+(Xi * Wi)+...+ (Xn * Wn)

The threshold is called theta. Lastly, there is the output: y. When a >= theta, y=1, else y=0. Notice that the output doesn't need to be discontinuous, since it could also be determined by a squashing function, s (or sigma), whose argument is a, and whose value is between 0 and 1. Then, y=s(a).

Figure 1. Threshold logic unit, with sigma function (top) and cutoff function (bottom)

A TLU can classify. Imagine a TLU that has two inputs, whose weights equal 1, and whose theta equals 1.5. When this TLU inputs <0,0>, <0,1>, <1,0>, and <1,1>, it outputs 0, 0, 0, and 1 respectively. This TLU classifies these inputs into two groups: the 1 group and the 0 group. Insofar as a human brain that knows about logical conjunction (Boolean AND) would similarly classify logically conjoined sentences, this TLU knows something like logical conjunction.

This TLU has a geometric interpretation that clarifies what is happening. Its four possible inputs correspond to four points on a Cartesian graph. From X₁*W₁+ X₂*W₂ = theta, in other words, the point at which the TLU switches its classificatory behavior, it follows that X₂ = -X₁ + 1.5. The graph of this equation cuts the four possible inputs into two spaces that correspond to the TLU's classifications. This is an instance of a more general principle about TLUs. In the case of a TLU with an arbitrary number of inputs, N, the set of possible inputs corresponds to a set of points in N-dimensional space. If these points can be cut by a hyperplane -- in other words, an N-dimensional geometric figure corresponding to the line in the above example -- then there is a set of weights and a threshold that define a TLU whose classifications match this cut.

How a TLU learns

Since TLUs can classify, they know stuff. Neural nets are also supposed to learn. Their learning mechanism is modeled on the brain's adjustments of its neural connections. A TLU learns by changing its weights and threshold. Actually, the weight-threshold distinction is somewhat arbitrary from a mathematical point of view. Recall that the critical point at which a TLU outputs 1 instead of 0 is when the SUM(Xi * Wi) >= theta. This is equivalent to saying that the critical point is when the SUM(X_i * W_i)+ (-1 * theta) >= 0. So, it is possible to treat -1 as a constant input whose weight, theta, is adjusted in learning, or, to use the technical term,training. In this case, y=1 when SUM(X_i * W_i)+ (-1 * theta) >= 0, else y=0.

During training, a neural net inputs:

A series of examples of the items to be classified
Their proper classifications or targets

Such input can be viewed as a vector: <X₁, X₂, ...,X_n, theta, t>, where t is the target or true classification. The neural net uses these to modify its weights, and it aims to match its classifications with the targets in the training set. More precisely, this is supervised training, as opposed to unsupervised training. The former is based on examples accompanied by targets, whereas the latter is based on statistical analysis (see Resources later in this article). Weight modification follows a learning rule. One idealized learning algorithm goes something like this:

Listing 1. Idealized learning algorithm

fully_trained = FALSE DO UNTIL (fully_trained): fully_trained = TRUE FOR EACH training_vector = <X1, X2, ..., Xn, theta, target>:: # Weights compared to theta a = (X1 * W1)+(X2 * W2)+...+(Xn * Wn) - theta y = sigma(a) IF y != target: fully_trained = FALSE FOR EACH Wi: MODIFY_WEIGHT(Wi)                  # According to the training rule IF (fully_trained): BREAK

You're probably wondering, "What training rule?" There are many, but one plausible rule is based on the idea that weight and threshold modification should be determined by a fraction of (t - y). This is accomplished by introducing alpha (0 < alpha < 1), which is called the learning rate. The change in W_i equals (alpha * (t - y) * Xi). When alpha is close to 0, the neural net will engage in more conservative weight modifications, and when it is close to 1, it will make more radical weight modifications. A neural net that uses this rule is known as a perceptron, and this rule is called the perceptron learning rule. One result about perceptrons, due to Rosenblatt, 1962 (see Resources), is that if a set of points in N-space is cut by a hyperplane, then the application of the perceptron training algorithm will eventually result in a weight distribution that defines a TLU whose hyperplane makes the wanted cut. Of course, to recall Keynes, eventually, we're all dead, but more than computational time is at stake, since we may want our neural net to make more than one cut in the space of possible inputs.

Our initial puzzle illustrates this. Suppose that you were given N characters of code that you knew to be either C, C++, Java, or Python. The puzzle is to construct a program that identifies the code's language. A TLU that could do this would need to make more than one cut in the space of possible inputs. It would need to cut this space into four regions, one for each language. This would be accomplished by training a neural net to make two cuts. One cut would divide the C/C++ from the Java/Python, and the other cut would divide the C/Java from the C++/Python. A net that could make these cuts could also identify the language of a source code sample. However, this requires our net to have a different structure. Before we describe this difference, let's briefly turn to practical considerations.

Figure 2. Preliminary (and insufficient) Perceptron Learning Model

Considerations of computational time rule out taking N-character chunks of code, counting the frequency of the visible ASCII characters, 32 through 127, and training our neural net on the basis of these counts and target information about the code's language. Our way around this was to limit our character counts to the twenty most frequently occurring non-alphanumeric characters in a pool of C, C++, Java, and Python code. For reasons that concern the implementation of floating point arithmetic, we decided to train our net with these twenty counts divided by a normalizing factor. Clearly, one structural difference is that our net has twenty input nodes, but this should not be surprising, since our description has already suggested this possibility. A more interesting difference is a pair of intermediary nodes, N1 and N2, and an increase in the number of output nodes from two to four, O1-O4.

N1 would be trained so that upon seeing C or C++, it would set y1=1, and upon seeing Java or Python, it would set y1=0. N2 would be similarly trained. Upon seeing C or Java, N2 would set y2=1, and upon seeing C++ or Python, it would set y2=0. Furthermore, N1 and N2 would output 1 or 0 to the Oi. Now, if N1 sees C or C++, and N2 sees C or Java, then the code in question is C. Moreover, if N1 sees C or C++, and N2 sees C++ or Python, the code is C++. The pattern is obvious. So, suppose that the Oi were trained to output 1 or 0 on the basis of the following table:

Intermediate nodes mapped to output (as Boolean functions)

N1	N2	O1 (C)	O2 (C++)	O3 (Java)	O4 (Python)
0	0	0	0	0	1
0	1	0	0	1	0
1	0	0	1	0	0
1	1	1	0	0	0

If this worked, our net could identify the language of a code sample. It is a pretty idea, and its practical ramifications seem to be incredibly far reaching. However, this solution presupposes that the C/C++ and the Java/Python inputs are cut by one hyperplane, and that the C/Java and the C++/Python inputs are cut by the other. There is an approach to net training that bypasses this kind of assumption about the input space.

The delta rule

Another training rule is the delta rule. The perceptron training rule is based on the idea that weight modification is best determined by some fraction of the difference between target and output. The delta rule is based on the idea of gradient descent. This difficult mathematical concept has a prosaic illustration. From some given point, a Southward path may be steeper than an Eastward path. Walking East may take you off a cliff, while walking South may only take you along its gently sloping edge. West would take you up a steep hill, and North leads to level ground. All you want is a leisurely walk, so you seek ground where the overall steepness of your options is minimized. Similarly, in weight modification, a neural net can seek a weight distribution that minimizes error.

Limiting ourselves to nets with no hidden nodes, but possibly having more than one output node, let p be an element in a training set, and t(p,n) be the corresponding target of output node n. However, let y(p,n) be determined by the squashing function, s, mentioned above, where a(p,n) is n's activation relative to p, y(p,n) = s( a(p,n) ) or the squashed activation of node n relative to p. Setting the weights (each Wi) for a net also sets the difference between t(p,n) and y(p,n) for every p and n, and this means setting the net's overall error for every p. Therefore, for any set of weights, there is an average error. However, the delta rule rests on refinements in the notions of average and error. Instead of discussing the minutiae, we shall just say that the error relative to some p and n is: ½ * square( t(p,n) - y(p,n) ) (see Resources). Now, for each Wi, there is an average error defined as:

Listing 2: Finding the average error

sum = 0 FOR p = 1 TO M:         # M is number of training vectors FOR n = 1 TO N:     # N is number of output nodes sum = sum + (1/2 * (t(p,n)-y(p,n))^2) average = 1/M * sum

The delta rule is defined in terms of this definition of error. Because error is explained in terms of all the training vectors, the delta rule is an algorithm for taking a particular set of weights and a particular vector, and yielding weight changes that would take the neural net on the path to minimal error. We won't discuss the calculus underpinning this algorithm. Suffice it to say that the change to any Wi is:

Â alpha * s'(a(p,n)) * (t(p,n) - y(p,n)) * X(p,i,n).

X(p,i,n) is the i^th element in p that is input into node n, and alpha is the already noted learning rate. Finally, s'( a(p,n) ) is the rate of change (derivative) of the squashing function at the activation of the n^th node relative to p. This is the delta rule, and Widrow and Stearns (see Resources) showed that when alpha is sufficiently small, the weight vector approaches a vector that minimizes error. A delta rule-based algorithm for weight modification looks like this.

Downward slope (follow until error is suitably small)

step 1: for each training vector, p, find a(p) step 2: for each i, change Wi by: alpha * s'(a(p,n)) * (t(p,n)-y(p,n)) * X(p,i,n)

There are important differences from the perceptron algorithm. Clearly, there are quite different analyses underlying the weight change formulae. The delta rule algorithm always makes a change in weights, and it is based on activation as opposed to output. Lastly, it isn't clear how this applies to nets with hidden nodes.

Back-propagation

Back-propagation is an algorithm that extends the analysis that underpins the delta rule to neural nets with hidden nodes. To see the problem, imagine that Bob tells Alice a story, and then Alice tells Ted. Ted checks the facts, and finds that the story is erroneous. Now, Ted needs to find out how much of the error is due to Bob and how much to Alice. When output nodes take their inputs from hidden nodes, and the net finds that it is in error, its weight adjustments require an algorithm that will pick out how much the various nodes contributed to its overall error. The net needs to ask, "Who led me astray? By how much? And, how do I fix this?" What's a net to do?

Figure 3. "Code Recognizer" back-propagation neural network

The back-propagation algorithm also rests on the idea of gradient descent, and so the only change in the analysis of weight modification concerns the difference between t(p,n) and y(p,n). Generally, the change to W_i is:

Â alpha * s'(a(p,n)) * d(n) * X(p,i,n)

where d(n) for a hidden node n, turns on (1) how much n influences any given output node; and (2) how much that output node itself influences the overall error of the net. On the one hand, the more n influences an output node, the more n affects the net's overall error. On the other hand, if the output node influences the overall error less, then n's influence correspondingly diminishes. Where d(j) is output node j's contribution to the net's overall error, and W(n,j) is the influence that n has on j, d(j) * W(n,j) is the combination of these two influences. However, n almost always influences more than one output node, and it may influence every output node. So, d(n) is:

Â SUM(d(j)*W(n,j)), for all j

where j is an output node that takes input from n. Putting this together gives us a training rule. First part: the weight change between hidden and output nodes, n and j, is:

Â alpha * s'(a(p,n))*(t(p,n) - y(p,n)) * X(p,n,j)

Second part: the weight change between input and output nodes, i and n, is:

Â alpha * s'(a(p,n)) * sum(d(j) * W(n,j)) * X(p,i,n)

where j varies over all the output nodes that receive input from n. Moreover, the basic outline of a back-propagation algorithm runs like this.

Initialize Wi to small random values.

Steps to follow until error is suitably small

Step 1: Input training vector.
Step 2: Hidden nodes calculate their outputs.
Step 3: Output nodes calculate their outputs on the basis of Step 2.
Step 4: Calculate the differences between the results of Step 3 and targets.
Step 5: Apply the first part of the training rule using the results of Step 4.
Step 6: For each hidden node, n, calculate d(n).
Step 7: Apply the second part of the training rule using the results of Step 6.

Steps 1 through 3 are often called the forward pass, and steps 4 through 7 are often called the backward pass. Hence, the name: back-propagation.

Recognizing success

With the back-propagation algorithm in hand, we can turn to our puzzle of identifying the language of source code samples. To do this, our solution extends Neil Schemenauer's Python module bpnn (see Resources). Using his module is amazingly simple. We customized the class NN in our class NN2, but our changes only modify the presentation and output of the process, nothing algorithmic. The basic code looks like:

Listing 3: Setting up a neural network with bpnn.py

# Create the network (number of input, hidden, and training nodes) net = NN2(INPUTS, HIDDEN, OUTPUTS)   # create the training and testing data trainpat = []   testpat = []   for n in xrange(TRAINSIZE+TESTSIZE):   #... add vectors to each set  # train it with some patterns net.train(trainpat, iterations=ITERATIONS, N=LEARNRATE, M=MOMENTUM)    # test it  net.test(testpat)    # report trained weights  net.weights()

Of course, we need input data. Our utility code2data.py provides this. Its interface is straightforward: just put a bunch of source files with various extensions into a subdirectory called ./code , and then run the utility listing these extensions as options, for example:

Â Â Â python code2data.py py c java

What you get is a bunch of vectors on STDOUT , which you can pipe to another process or redirect to a file.Â This output looks something like:

Listing 4: Code2Data output vectors

0.15 0.01 0.01 0.04 0.07 0.00 0.00 0.03 0.01 0.00 0.00 0.00 0.05 0.00 > 1 0 0 0.14 0.00 0.00 0.05 0.13 0.00 0.00 0.00 0.02 0.00 0.00 0.00 0.13 0.00 > 1 0 0 [...]

Recall that the input values are normalized numbers of occurrences of various special characters. The target values (after the greater than sign) are YES/NO representing the type of source code file containing these characters. But there is nothing very obvious about what is what. That's the great thing, the data could by anything that you can generate input and targets for.

The next step is to run the actual code_recognizer.py program. This takes (on STDIN ) a collection of vectors like those above. The program has a wrapper that deduces how many input nodes (count and target) are needed, based on the actual input file. Choosing the number of hidden nodes is trickier. For source code recognition, 6 to 8 hidden nodes seem to work very well. You can override all the parameters on the command line, if you want to experiment with the net to discover how it does with various options -- each run might take a while, though. It is worth noting that code_recognizer.py sends its (large) test result file to STDOUT , but puts some friendly messages on STDERR . So most of the time, you will want to direct STDOUT to a file for safe keeping, and watch STDERR for progress and result summaries.

Listing 5: Running code_recognizer.py

> code2data.py py c java | code_recognizer.py > test_results.txt  Total bytes of py-source: 457729  Total bytes of c-source: 245197  Total bytes of java-source: 709858  Input set: ) ( _ . = ; " , ' * / { } : - 0 + 1 [ ]  HIDDEN = 8  LEARNRATE = 0.5  ITERATIONS = 1000  TRAINSIZE = 500  OUTPUTS = 3  MOMENTUM = 0.1  ERROR_CUTOFF = 0.01  TESTSIZE = 500  INPUTS = 20  error -> 95.519... 23.696... 19.727... 14.012... 11.058... 9.652...   8.858... 8.236... 7.637... 7.065... 6.398... 5.413... 4.508...   3.860... 3.523... 3.258... 3.026... 2.818... 2.631... 2.463...   2.313... 2.180... 2.065... 1.965... 1.877... 1.798... 1.725...   [...]  0.113... 0.110... 0.108... 0.106... 0.104... 0.102... 0.100...   0.098... 0.096... 0.094... 0.093... 0.091... 0.089... 0.088...   0.086... 0.085... 0.084...  Success rate against test data: 92.60%

The decreasing error is a nice reminder, and acts as a sort of progress meter during long runs. But, the final result is what is impressive. The net does a quite respectable job, in our opinion, of recognizing code -- we would love to hear how it does on your data vectors.

Source:

http://www.ibm.com/developerworks/library/l-neural/

Crowd Simulation - Intelligent Agents Simulation

2011-07-26T12:16:00.001+03:00

Camera Flash Effect With JQuery

2011-07-25T16:31:00.001+03:00

You can see the working demo here. Go to the page and Click anywhere to generate the effect.

Code

Include SoundManager for Sound

<script type='text/javascript' src='script/soundmanager.js'></script&gt; <script type="text/javascript">soundManagerInit();</script>

Learn more about it.

CSS

  body{

    background:black; }  .flashDiv{

    position:fixed;  top:0;

    left:0;

    width:100%;

    height:100%;

    background-color:#fff;

JavaScript

function flash(e)

$('.flashDiv') .show()  //show the hidden div .animate({opacity: 0.5}, 300)  .fadeOut(300)

        .css({'opacity': 1});     //play the sound

    soundManager.play('capture'); }

$(document).ready(function()

{         $('.flashDiv').hide();

    $(document).mouseup(function(e) { flash(e); }) });

HTML
Include this div to the body

<div class='flashDiv'></div>

Freelance Freedom

2011-07-10T19:56:00.001+03:00

Resources: Freelance Freedom

Inner eye Project

2011-07-10T19:45:00.004+03:00

While Microsoft tend to support more Natural User Interface (NUI) projects, as most celebrated example its early NUI work is the Kinect Xbox body motion sensor, there’s also quite a bit of focus by Microsoft’s NUI researchers on the intersection between NUI and healthcare. There are a number of Microsoft Research projects exploring the NUI-health connection. One of these projects, named “Inner Eye” is focused on the medical automation analysis of Computed Tomography ( CT ) scans, using modern machine learning techniques as 3D model navigation and visualization.
InnerEye takes advantage of advances in computer-human interactions that have put computers on a path to work for us and collaborate with us. The development of a natural user interface (NUI) enables computers to adapt to you and be more integrated into your environment via speech, touch, and gesture. As NUI systems become more powerful and are imbued with more situational awareness, they can provide beneficial, real-time interactions that will be seamless and naturally suited to your context—in short, systems will understand where you are and what you’re doing
Antonio Criminisi, as a leader of the research group of Microsoft’s Research center in Cambridge, who develop the system that will make it easier for doctors to work with databases of medical imagery. This system indexes the images generated during the scans. It automatically recognizes organs, and they are working to train the system to detect certain kinds of brain tumors.
This software snaps a collection of 2D and 3D images and index them all together. After combining them all together, medical imaging databases are created using the text comments linked to the image for doctors to search. This gives them the ability to search, but it takes time because not all of the results are relevant. These kinds of systems will allow doctors to easily navigate from new images to old images in the same patient, side-by-side. It will also allow doctors to easily pull up images from other patients for comparison.
Criminisi’s team is also working on embedding the technology found in Kinect. This will give surgeons the ability to navigate through the images with gestures. This will give them access to the images mid-procedure without them having to touch a mouse, keyboard, or even a touch screen. As these are all things that could compromise the sterility of the operation, this will be a very useful tool. The team plans for this tool to be implemented at a large scale, making automatic indexes of images as they are scanned and tying them into the greater database seamlessly.
Using Kinect technology, they would only have to motion their hands to access the parts they need to focus on. The potential Microsoft solution is quicker and slicker: And it could help to save lives. Criminisi said: “Our solution enables surgeons to wave at the screen and access the patients images without touching any physical device, thus maintaining asepsis. By gesturing in mid-air surgeons can zoom in on specific organs or lesions and manipulate 3D views; they can also search for images of other patients with similar conditions. It’s amazing how such images can offer clues of disease and potential cure. Pre-filtering patient data can be an important tool for doctors and surgeons.”
Although needs in each hospitals different and levels of sophistication, the general outcome was sufficiently encouraging to drive scientific research towards a new, efficient tool to aid surgery.

Resources:

Tecnology Review
Pappas Evangelos. 30/03/2010 - Assesment for CO3 6th Semester Academic English. University of Wales

JavaScript Attack/Defend

2011-07-10T13:48:00.001+03:00

As developers and designers we work hard to build visually attractive, fast and easy to maintain applications. Our goals are to make sure the applications we build stick to users and keep them coming back for more. Security is not always at the forefront of our minds. No one intentionally builds insecure software but often a lack of security knowledge leads developers to build vulnerabilities into their applications. In this article we are going to examine two web security attacks, how they are executed and how to defend against them. By the end of this article you will have a few techniques in your security tool belt to help you build more secure web applications.

The Open Web Application Security Project (OWASP) is a global organization that focuses on improving web application security and security awareness among the developer community. OWASP maintains a list of what are considered the most serious top ten security threats to web applications: the OWASP Top Ten project. We are going to examine two attacks from the Top Ten list, Cross Site Scripting (XSS) and Cross Site Request Forgery (CSRF). These attacks are both widespread and can be easily overlooked when developing an application. The good news is that finding these attacks is simple and building mitigations for them is just as easy.

Cross Site Scripting (XSS)

Many web applications today allow users to generate content to share with other users. To find examples of this look no further than a corporate blog. Many companies use blogs to communicate with their customers by writing about new products, ad campaigns, or just the everyday happenings of the business. To encourage a conversation between the customer and company, these blogs permit comments. Comments are user generated content that is posted to the blog for others to see, including the company’s blog administrator. In this scenario, Cross Site Scripting attacks occur when a user leaves a comment on the blog with the intent to execute a malicious payload against another user.

Cross Site Scripting (XSS) is an exploitation of the trust that the user has with the web site where the attack is hosted. When a user is interacting with a site that they trust they do not expect that a malicious user has poisoned the site against them. Anywhere in a site that allows input from a user opens the door for a possible XSS attack. The malicious input is often in the form of some client side script (usually JavaScript but it could also be VBScript, ActionScript, etc…) that executes when the user performs an action such as clicking a link or loading the page.

Three Types of XSS

Three Types of XSS There are three types of XSS attacks:

Stored: The attack is saved into a persistent storage medium such as a database or file.
Reflected: Non-persistent attacks needing a delivery method to initiate the attack such an email or malicious form.
DOM based XSS: This attack manipulates the DOM to execute the attack payload.

For this article we will be referring to Reflected XSS in our examples but the defenses we will cover work for all the flavors of XSS. More information can be found at: https://www.owasp.org/index.php/Cross-site_Scripting_(XSS)XSS attacks can impact your users in a variety of ways. The attack can steal information from the user, perform unintended actions in the application or even load malicious software to the user’s machine. A XSS attack can also have significant impacts on your web application as well. Once the attack is exposed, users will lose faith in the safety of your application causing damage to your company’s reputation.

XSS Attack

So how does a XSS attack work? Here is an example of a very simple Reflected XSS attack:

<span id="message-text">
<%=Request.QueryString["msg"]%>
</span>

This quick code snippet grabs a string from the query string variable named “msg” and writes it directly to the HTML element “message-text”. Imagine the query string variable was the following:

<script>alert('123');</script>

This would load the script tag and execute the alert message to the HTML of message-text.

While this example is very simplistic, XSS attacks can become more difficult to find when they are invoked from an Ajax request or when created during a data binding expression. When the attack is brought to the page from a database or other stored data, which is called a Stored XSS Attack. The example of the corporate blog is a Stored XSS attack as the malicious user has left the code to perform the XSS attack in the corporate blog Comments database.

XSS Defense

To defend against XSS attacks you must be conscious of input to your application. Input can come from many different sources such as configuration files, databases, web services, and any other source that populates the application with data. With this in mind, the best defense against XSS is sanitizing data as it is input into your application.

Fortunately sanitizing your input is simple using tools like the Microsoft AntiXSS Library (available for download at http://www.microsoft.com/downloads/en/details.aspx?FamilyID=f4cd231b-7e06-445b-bec7-343e5884e651). This code library makes it very easy to sanitize code on the server side. Using the AntiXSS library for our above example, we would update the code to be the following:

<span id="message-text">
<%=Microsoft.Security.Application.Encoder.HtmlEncode(Request.QueryString["msg"])%>
</span>

The library offers a multitude of encoding options including JavaScript, CSS, and XML encoding among others. Using the Anti-XSS Library, you can clean the input going in to your data store and sanitize the output coming through your application. While this library is an excellent resource for server side coding, sometimes you need a client side sanitizer to make sure the data you retrieve in JavaScript is clean.

The OWASP Enterprise Security API (ESAPI) is one of the many projects available on the OWASP site. This API allows developers to wrap output into encoder methods for most development platforms. The JavaScript ESAPI library can be found athttps://www.owasp.org/index.php/Category:OWASP_Enterprise_Security_API#tab=JavaScript. Encoding with the ESAPI JavaScript library is just as simple as using the AntiXSS encoder. Here is an example:

<script src="Scripts/jquery-1.4.1.js" type="text/javascript"></script>
<script src="Scripts/lib/log4js.js" type="text/javascript"></script>
<script src="Scripts/esapi.js" type="text/javascript"></script>
<script src="Scripts/resources/i18n/ESAPI_Standard_en_US.properties.js" type="text/javascript"></script>
<script src="Scripts/resources/Base.esapi.properties.js" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
function cleanData() {
org.owasp.esapi.ESAPI.initialize();
var cleanedInput = $ESAPI.encoder().encodeForHTML("<script>alert('123');<//script>");
$("#message-text").html(cleanedInput);
}
</script>

Using the $ESAPI object, we can encode the malicious string to be treated like text data and not interpreted like HTML tags. The ESAPI encoder is an excellent tool to ensure clean data from Mashups or the results of an Ajax call.

Libraries like the Anti-XSS library and ESAPI do have a downside, performance. By channeling all your data through a sanitization library, you incur some overhead in the application. The security benefit from using these libraries far outweighs the slight performance hit as XSS attacks can damage not just your company’s image but also your user’s information.

Cross Site Request Forgery (CSRF)

While XSS exploits the user’s trust in a specific web site, Cross Site Request Forgery (CSRF) exploits a user’s trust in how their Web Browser works. A CSRF attack happens when an attacker crafts a malicious HTTP request and then tricks the user into executing the request. When an HTTP request is sent to a web site all the cookies, session and header information are sent as well. With this in mind, using CSRF an attacker could execute commands against a site posing as the user.

Let’s look at an example of this attack. One day a user is checking their bank balance online using the new XYZBank.com website. The user makes a few transfers moving money around different accounts. Leaving the site, the user clicks around on the web until they land on the corporate blog we discussed in the XSS example. The user reads the latest blog entry and looks at the various comments. One of the comments was left by a malicious user who has setup an invisible image tag whose SRC attribute is an HTTP request to transfer money from the users account to the attacker’s account. Since the user was already authenticated to the XYZBank.com website, the browser and server assume this is a valid request from the user and executes the money transfer. The next time the user goes to XYZBank.com and sees they are missing money; it is likely they will assume their account was hacked and not connect the loss to the corporate blog.

CSRF Attack

Building a CSRF attack requires a lot of homework. The first step of any attack is building a profile on the target, in this case XYZBank.com. By using the banking site, the attacker can learn what cookies are stored, what fields perform what actions, how data flows through the site, etc… By creating an account on XYZBank.com and using the site, our attacker has learned the following items:

Primary account number is stored in a cookie to save the user from selecting which account is their primary account on each visit.
On the money transfer page there are three fields required to transfer money:
- Source Account Number: Where the money is coming from. If the value is blank, the site assumes the use of the Primary Account.
- Destination Account Number: Where the money is going to
- Dollar amount: How much is being transferred
The site also uses query string parameters for persisting data between HTTP requests.

Using this information, the attacker can create the following image tag:

<img src="https://www.xyzbank.com/transfer.php?txtSource=&txtDest=[Attacker's Account]&txtAmount=1500" width="0" height="0" />

This zero height, zero width image would be invisible to the user but when the image is called by the Browser, the SRC attribute will send the transfer request to XYZBank.com. When the request is sent, the cookies and session for any existing connections to XYZBank.com will be sent as well making the website think that the request is legitimate. CSRF attacks can use images as in the example above or they could use anything that can make an HTTP request.

CSRF Defense

While XSS defense is simply a matter of cleaning data in your system, CSRF exploits how an Internet Browser is supposed to work. The good news is that there are multiple defenses that you can put in place to protect your application against CSRF. We will examine a few server side options first and then discuss some best practices to present to your users on how they can defend against CSRF on other sites.

Our goal is to create multiple layers of defense against a CSRF attack. The first step to this is to try and validate that the request is coming from your own site (in this case, a request to XYZBank.com is coming from XYZBank.com). Checking the HTTP Referrer Header can usually tell you where a request is coming from. This HTTP Header keeps track of where the HTTP request originatedfrom (for more information about the HTTP Referrer Header see:http://www.w3.org/Protocols/HTTP/HTRQ_Headers.html#z14). If the request originates from XYZBank.com then the HTTP Referrer will be XYZBank.com. Unfortunately, the Referrer Header can be spoofed and is not always present for every HTTP request. Checking the Referrer is simply an added layer of validation that you can use.

A much more reliable method for preventing CSRF attacks is to use the Synchronizer Token Pattern. This design pattern uses a randomly generated token that is associated with a user’s session to ensure that the request originated from the site. The random token is then stored in a hidden field and checked on each request. Using this method, the attacker would not be able to guess the random token (as it is only stored in a hidden field) and thus the request would be rejected. Using this method we would setup a Hidden Field on the HTML page and populate it with a random token:

<input type="hidden" id="hdn1" value="29ldfoa9210129041jljfmcaoj39141" />

Now, for our banking site we would be expecting another parameter in the query string. The requested URL would now look like the following:

https://www.xyzbank.com/transfer.php?txtSource=&txtDest=[Attacker's Account]&txtAmount=1500&hdn1=29ldfoa9210129041jljfmcaoj39141

When the request arrives at the transfer.php page, we can check the value of “hdn1” against what has been stored in the Session. If the values match, then the request is valid and can continue. If not, then the request is rejected and an error message presented to the user.

For ASP.NET developers, ViewState already validates the requests coming in to the server but it is possible to forge or copy a ViewState with known valid data. By default, ViewState is not tied to a particular user but by using the Page.ViewStateUserKey, developers can bind a ViewState to a specific user or session. Setting the ViewStateUserKey to the SessionID will make the ViewState valid only for that SessionID so if an attacker attempts to reuse/forge the ViewState value, the ASP.NET application will see the request as invalid. Enabling this ViewState feature is simple. Add the following to the Page_PreInit method of your ASP.NET page:

void Page_PreInit(object sender, EventArgs e)
{
Page.ViewStateUserKey = Session.SessionID;
}

You could use other properties such as User ID but whatever data point you use, it must be unique per user. Otherwise, it totally defeats the purpose of the ViewStateUserKey and opens your application to ViewState forgery.

The best defense against CSRF is an easy tactic that your users can do…just log out. Most CSRF attacks leverage actions that are available to authenticated users. Encourage your users to log out from your site and others when they are finished. Learn more about all of these defenses and more on the OWASP CSRF Prevention Cheat Sheet.

Tip of the iceberg

The two attacks we examined in this article, Cross Site Scripting (XSS) and Cross Site Request Forgery (CSRF), are common attacks but not the only security threats on the web. OWASP’s Top Ten list is an excellent resource to start your web application security training. Correcting XSS and CSRF vulnerabilities on your site is an excellent starting point on your application security journey. By increasing your security awareness implementing some of the mitigations presented in this article, you will be well on your way to protecting your user’s data and the reputation of your application.

Reference: ScriptJunkie By Tim Kulp

How to Crack a Wi-Fi Network.

2011-07-10T13:33:00.001+03:00

You already know that if you want to lock down your Wi-Fi network, you should opt for WPA encryption because WEP is easy to crack. But did you know how easy? Take a look.

This tutorial is for information purposes only, and I do not endorse any of the activities discussed within this guide. I nor anyone hosting this guide can be held responsible for anything you do after reading this. What you do with your day lies on your shoulders.

1.Black Track

Today we’re going to run down, step-by-step, how to crack a Wi-Fi network with WEP security turned on. But first, a word: Knowledge is power, but power doesn’t mean you should be a jerk, or do anything illegal. Knowing how to pick a lock doesn’t make you a thief. Consider this post educational, or a proof-of-concept intellectual exercise.

Dozens of tutorials on how to crack WEP are already all over the internet using this method. Seriously—Google it. This ain’t what you’d call “news.” But what is surprising is that someone like me, with minimal networking experience, can get this done with free software and a cheap Wi-Fi adapter. Here’s how it goes.

What You’ll Need.

Unless you’re a computer security and networking ninja, chances are you don’t have all the tools on hand to get this job done. Here’s what you’ll need:

* A compatible wireless adapter—This is the biggest requirement. You’ll need a wireless adapter that’s capable of packet injection, and chances are the one in your computer is not. After consulting with my friendly neighborhood security expert, I purchased an Alfa AWUS050NH USB adapter, pictured here, and it set me back about $50 on Amazon. Update: Don’t do what I did. Get the Alfa AWUS036H, not the US050NH, instead. The guy in this video below is using a $12 model he bought on Ebay (and is even selling his router of choice). There are plenty of resources on getting aircrack-compatible adapters out there.

* A BackTrack 3 Live CD. We already took you on a full screenshot tour of how to install and use BackTrack 3, the Linux Live CD that lets you do all sorts of security testing and tasks. Download yourself a copy of the CD and burn it, or load it up in VMware to get started. (I tried the BackTrack 4 pre-release, and it didn’t work as well as BT3. Do yourself a favor and stick with BackTrack 3 for now.)

* A nearby WEP-enabled Wi-Fi network. The signal should be strong and ideally people are using it, connecting and disconnecting their devices from it. The more use it gets while you collect the data you need to run your crack, the better your chances of success.

* Patience with the command line. This is an ten-step process that requires typing in long, arcane commands and waiting around for your Wi-Fi card to collect data in order to crack the password. Like the doctor said to the short person, be a little patient.

Crack That WEP

To crack WEP, you’ll need to launch Konsole, BackTrack’s built-in command line. It’s right there on the taskbar in the lower left corner, second button to the right. Now, the commands.

First run the following to get a list of your network interfaces:

airmon-ng

The only one I’ve got there is labeled ra0. Yours may be different; take note of the label and write it down. From here on in, substitute it in everywhere a command includes (interface).

Now, run the following four commands. See the output that I got for them in the screenshot below.

airmon-ng stop (interface)
ifconfig (interface) down
macchanger –mac 00:11:22:33:44:55 (interface)
airmon-ng start (interface)

If you don’t get the same results from these commands as pictured here, most likely your network adapter won’t work with this particular crack. If you do, you’ve successfully “faked” a new MAC address on your network interface, 00:11:22:33:44:55.

Now it’s time to pick your network. Run:

airodump-ng (interface)

To see a list of wireless networks around you. When you see the one you want, hit Ctrl+C to stop the list. Highlight the row pertaining to the network of interest, and take note of two things: its BSSID and its channel (in the column labeled CH), . Obviously the network you want to crack should have WEP encryption (in the ENC) column, not WPA or anything else.

Like I said, hit Ctrl+C to stop this listing. (I had to do this once or twice to find the network I was looking for.) Once you’ve got it, highlight the BSSID and copy it to your clipboard for reuse in the upcoming commands.

Now we’re going to watch what’s going on with that network you chose and capture that information to a file. Run:

airodump-ng -c (channel) -w (file name) –bssid (bssid) (interface)

Where (channel) is your network’s channel, and (bssid) is the BSSID you just copied to clipboard. You can use the Shift+Insert key combination to paste it into the command. Enter anything descriptive for (file name). I chose “yoyo,” which is the network’s name I’m cracking.

You’ll get output like what’s in the window in the background pictured below. Leave that one be. Open a new Konsole window in the foreground, and enter this command:

aireplay-ng -1 0 -a (bssid) -h 00:11:22:33:44:55 -e (essid) (interface)

Here the ESSID is the access point’s SSID name, which in my case is yoyo. What you want to get after this command is the reassuring “Association successful” message with that smiley face.

You’re almost there. Now it’s time for:

aireplay-ng -3 -b (bssid) -h 00:11:22:33:44:55 (interface)

Here we’re creating router traffic to capture more throughput faster to speed up our crack. After a few minutes, that front window will start going crazy with read/write packets. (Also, I was unable to surf the web with the yoyo network on a separate computer while this was going on.) Here’s the part where you might have to grab yourself a cup of coffee or take a walk. Basically you want to wait until enough data has been collected to run your crack. Watch the number in the “#Data” column—you want it to go above 10,000. (Pictured below it’s only at 854.)

Depending on the power of your network (mine is inexplicably low at -32 in that screenshot, even though the yoyo AP was in the same room as my adapter), this process could take some time. Wait until that #Data goes over 10k, though—because the crack won’t work if it doesn’t. In fact, you may need more than 10k, though that seems to be a working threshold for many.

Once you’ve collected enough data, it’s the moment of truth. Launch a third Konsole window and run the following to crack that data you’ve collected:

aircrack-ng -b (bssid) (file name-01.cap)

Here the filename should be whatever you entered above for (file name). You can browse to your Home directory to see it; it’s the one with .cap as the extension.

If you didn’t get enough data, aircrack will fail and tell you to try again with more. If it

Problems Along the Way

With this article I set out to prove that cracking WEP is a relatively “easy” process for someone determined and willing to get the hardware and software going. I still think that’s true, but unlike the guy in the video below, I had several difficulties along the way. In fact, you’ll notice that the last screenshot up there doesn’t look like the others—it’s because it’s not mine. Even though the AP which I was cracking was my own and in the same room as my Alfa, the power reading on the signal was always around -30, and so the data collection was very slow, and BackTrack would consistently crash before it was complete. After about half a dozen attempts (and trying BackTrack on both my Mac and PC, as a live CD and a virtual machine), I still haven’t captured enough data for aircrack to decrypt the key.

So while this process is easy in theory, your mileage may vary depending on your hardware, proximity to the AP point, and the way the planets are aligned. Oh yeah, and if you’re on deadline—Murphy’s Law almost guarantees it won’t work if you’re on deadline.

Video.

2.Comm View For WiFi

CommView for WiFi is a powerful wireless network monitor and analyzer for 802.11 a/b/g/n networks. Loaded with many user-friendly features, CommView for WiFi combines performance and flexibility with an ease of use unmatched in the industry.

CommView for WiFi captures every packet on the air to display important information such as the list of access points and stations, per-node and per-channel statistics, signal strength, a list of packets and network connections, protocol distribution charts, etc. By providing this information, CommView for WiFi can help you view and examine packets, pinpoint network problems, and troubleshoot software and hardware.

CommView for WiFi includes a VoIP module for in-depth analysis, recording, and playback of SIP and H.323 voice communications.

Packets can be decrypted utilizing user-defined WEP or WPA-PSK keys and are decoded down to the lowest layer. With over 70 supported protocols, this network analyzer allows you to see every detail of a captured packet using a convenient tree-like structure to display protocol layers and packet headers. Additionally, the product provides an open interface for plugging in custom decoding modules. WEP and WPA key retrieval add-ons are available subject to terms and conditions.

A number of case studies describe real-world applications of CommView for WiFi in business, government, and education sectors.

CommView for WiFi is a comprehensive and affordable tool for wireless LAN administrators, security professionals, network programmers, or anyone who wants to have a full picture of the WLAN traffic. This application runs under Windows XP/2003/Vista/2008/7 and requires a compatible wireless network adapter. To view the list of the adapters that have been tested and are compatible with CommView for WiFi, click on the link below:

SUPPORTED ADAPTERS

If your wireless card is not on the list, please click here for the technical information, or take advantage of our special offer and get a compatible adapter free of charge!

What you can do with CommView for WiFi

Scan the air for WiFi stations and access points.
Capture 802.11a, 802.11b, 802.11g, and 802.11n WLAN traffic.
Specify WEP or WPA keys to decrypt encrypted packets.
View detailed per-node and per-channel statistics.
View detailed IP connections statistics: IP addresses, ports, sessions, etc.
Reconstruct TCP sessions.
Configure alarms that can notify you about important events, such as suspicious packets, high bandwidth utilization, unknown addresses, rogue access points, etc.
View protocol “pie” charts.
Monitor bandwidth utilization.
Browse captured and decoded packets in real time.
Search for strings or hex data in captured packet contents.
Log individual or all packets to files.
Load and view capture files offline.
Import and export packets in Sniffer®, EtherPeek™, AiroPeek™, Observer®, NetMon, Tcpdump, hex, and text formats.
Export any IP address to SmartWhois for quick, easy IP lookup.
Capture data from multiple channels simultaneously using several USB adapters.
Capture A-MPDU and A-MSDU packets.
And much more!

Who needs CommView for WiFi

WLAN administrators.
Security professionals.
Home users who are interested in monitoring their WLAN traffic.
Programmers developing software for wireless networks.

An evaluation version is available in the Download Area.

To purchase this product, add it to the shopping cart (see the link at the top right corner of this page) or visit the Product Catalog. If you purchased this product in the past and would like to purchase an upgrade to the latest version, please visit theUpgrades page.

3. AirCrack NG

Aircrack-ng is an 802.11 WEP and WPA-PSK keys cracking program that can recover keys once enough data packets have been captured. It implements the standard FMS attack along with some optimizations like KoreK attacks, as well as the all-new PTW attack, thus making the attack much faster compared to other WEP cracking tools.In fact, Aircrack-ng is a set of tools for auditing wireless networks.

Packet injection on a phone Aircrack-ng suite now fully works with the internal card of the Nokia N900, including packet injection.

Sources

Aircrack-ng 1.1
SHA1: 16eed1a8cf06eb8274ae382150b56589b23adf77
MD5: f7a24ed8fad122c4187d06bfd6f998b4

Development sources:
- Aircrack-ng: svn co http://trac.aircrack-ng.org/svn/trunk/ aircrack-ng
- Airoscript-ng: svn co http://trac.aircrack-ng.org/svn/branch/airoscript-ng/ airoscript-ng

Binaries

Aircrack-ng 1.1 (Windows)
SHA1: 043ac7346cfd4878eb3af9783554873fbb5c28d4
MD5: 407e342f01f6d46886a9f908b241d53a

Important information:

This version requires you to develop your own DLLs to link aircrack-ng to your wireless card (it will not work without).
The required DLLs are not provided in the download and there will be no support for them.

Aircrack-ng 0.9.3 (Windows, supports airpcap devices)
SHA1: 590d3e8fd09a21b93908d84057959cb13e73d378
MD5: cbcb23c55ed6933a48b8af5665104fb6

Linux packages can be found here.

Previous versions

Previous versions of Aircrack-ng can be found here.
A backup of the original versions (from Christophe Devine) are available here.
Previous versions of Slitaz Aircrack-ng can be found here.
Previous versions of our VMWare appliance can be found here.

Other downloads

Aircrack-ng VMware image v4
Transmission Mini VM Appliance – Very light VMware image (15Mb) for rt73 devices only (More information in the forum)
Slitaz Aircrack-ng Live CD (24 November 2009)

Sample files

test.ivs – This is a 128 bit WEP key file. The key is AE:5B:7F:3A:03:D0:AF:9B:F6:8D:A5:E2:C7.
ptw.cap – This is a 64 bit WEP key file suitable for the PTW method. The key is 1F:1F:1F:1F:1F.

Changelog

Aircrack-ng complete changelog

References: Arrow Webzine & Nyjil George

Academic Search Engines: Beyond Google Scholar

2011-07-10T13:25:00.001+03:00

Scirus

Scirus has a pure scientific focus. It is a far reaching research engine that can scour journals, scientists’ homepages, courseware, pre-print server material, patents and institutional intranets.

InfoMine

Infomine has been built by a pool of libraries in the United States. Some of them are University of California, Wake Forest University, California State University, and the University of Detroit. Infomine “˜mines’ information from databases, electronic journals, electronic books, bulletin boards, mailing lists, online library card catalogs, articles, directories of researchers, and many other resources.

You can search by subject category and further tweak your search using the search options. Infomine is not only a standalone search engine for the Deep Web but also a staging point for a lot of other reference information. Check out its Other Search Tools and General Reference links at the bottom.

The WWW Virtual Library

This is considered to be the oldest catalog on the web and was started by started by Tim Berners-Lee, the creator of the web. So, isn’t it strange that it finds a place in the list of Invisible Web resources? Maybe, but the WWW Virtual Library lists quite a lot of relevant resources on quite a lot of subjects. You can go vertically into the categories or use the search bar. The screenshot shows the alphabetical arrangement of subjects covered at the site.

DeepPeep

DeepPeep aims to enter the Invisible Web through forms that query databases and web services for information. Typed queries open up dynamic but short lived results which cannot be indexed by normal search engines. By indexing databases, DeepPeep hopes to track 45,000 forms across 7 domains.

The domains covered by DeepPeep (Beta) are Auto, Airfare, Biology, Book, Hotel, Job, and Rental. Being a beta service, there are occasional glitches as some results don’t load in the browser.

Reference: 10 Search Engines to Explore the Invisible Web

Evolution machine: Genetic engineering on fast forward

2011-07-10T13:11:00.001+03:00

Source: NewScientist

Automated genetic tinkering is just the start – this machine could be used to rewrite the language of life and create new species of humans

IT IS a strange combination of clumsiness and beauty. Sitting on a cheap-looking worktop is a motley ensemble of flasks, trays and tubes squeezed onto a home-made frame. Arrays of empty pipette tips wait expectantly. Bunches of black and grey wires adorn its corners. On the top, robotic arms slide purposefully back and forth along metal tracks, dropping liquids from one compartment to another in an intricately choreographed dance. Inside, bacteria are shunted through slim plastic tubes, and alternately coddled, chilled and electrocuted. The whole assembly is about a metre and a half across, and controlled by an ordinary computer.

Say hello to the evolution machine. It can achieve in days what takes genetic engineers years. So far it is just a prototype, but if its proponents are to be believed, future versions could revolutionise biology, allowing us to evolve new organisms or rewrite whole genomes with ease. It might even transform humanity itself.

These days everything from your food and clothes to the medicines you take may well come from genetically modified plants or bacteria. The first generation of engineered organisms has been a huge hit with farmers and manufacturers - if not consumers. And this is just the start. So far organisms have only been changed in relatively crude and simple ways, often involving just one or two genes. To achieve their grander ambitions, such as creating algae capable of churning out fuel for cars, genetic engineers are now trying to make far more sweeping changes.

Grand ambitions

Yet changing even a handful of genes takes huge amounts of time and money. For instance, a yeast engineered to churn out the antimalarial drug artemisinin has been hailed as one of the great success stories of synthetic biology. However, it took 150 person-years and cost $25 million to add or tweak around a dozen genes - and commercial production has yet to begin.

The task is so difficult and time-consuming because biological systems are so complex. Even simple traits usually involve networks of many different genes, which can behave in unpredictable ways. Changes often do not have the desired effect, and tweaking one gene after another to get things working can be a very slow and painstaking process.

Many biologists think the answer is to try to eliminate the guesswork. They are creating libraries of ready-made "plug-and-play" components that should behave in a reliable way when put together to create biologicial circuits. But George Church, a geneticist at Harvard Medical School in Boston, thinks there is a far quicker way: let evolution do all the hard work for us. Instead of trying to design every aspect of the genetic circuitry involved in a particular trait down to the last DNA letter, his idea is to come up with a relatively rough design, create lots of variants on this design and select the ones that work best.

The basic idea is hardly original; various forms of directed evolution are already used to design things as diverse as proteins and boats. Church's group, however, has developed a machine for "evolving" entire organisms - and it works at an unprecedented scale and speed. The system has the potential to add, change or switch off thousands of genes at a time - Church calls this "multiplexing" - and it can generate billions of new strains in days.

Of course, there are already plenty of ways to generate mutations in cells, from zapping them with radiation to exposing them to dangerous chemicals. What's different about Church's machine is that it can target the genes that affect a particular characteristic and alter them in specific ways. That greatly increases the odds of success. Effectively, rather than spending years introducing one set of specific changes, bioengineers can try out thousands of combinations at once. Peter Carr, a bioengineer at MIT Media Lab who is part of the group developing the technology, describes it as "highly directed evolution".

The first "evolution machine" was built by Harris Wang, a graduate student in Church's lab. To prove it worked, he started with a strain of the E. colibacterium that produced small quantities of lycopene, the pigment that makes tomatoes red. The strain was also modified to produce some viral enzymes. Next, he synthesised 50,000 DNA strands with sequences that almost matched parts of the 24 genes involved in lycopene production, but with a range of variations that he hoped would affect the amount of lycopene produced. The DNA and the bacteria were then put into the evolution machine.

The machine let the E. coli multiply, mixed them with the DNA strands, and applied an electric shock to open up the bacterial cells and let the DNA get inside. There, some of the added DNA was swapped with the matching target sequences in the cells' genomes. This process, called homologous recombination, is usually very rare, which is where the viral enzymes come in. They trick cells into treating the added DNA as its own, greatly increasing the chance of homologous recombination.

The effect was to create new variants of the targeted genes while leaving the rest of the genome untouched. It was unlikely that all 24 genes would be altered simultaneously in any one bacterium, so the cycle was repeated over and over to increase the proportion of cells with mutations in all 24 genes.

Repeating the cycle 35 times generated an estimated 15 billion new strains, each with a different combination of changes in the target genes. Some made five times as much lycopene as the original strain, Wang's team reported in 2009 ( Nature, vol 460, p 894).

It took Wang just three days to do better than the biosynthesis industry has managed in years. And it was no one-off - he has since repeated the trick for the textile dye indigo.

Church calls this bold approach multiplex automated genome engineering, or MAGE. In essence, he has applied the key principles that have led to the astonishing advances in DNA sequencing - parallel processing and automation - to genetic engineering. And since Church was one of the founders of the human genome project and helped develop modern sequencing methods, he knows what he is doing.

Just as labs all over the world now buy thousands of automated DNA sequencing machines, so Church envisions them buying automated evolution machines. He hopes to sell them relatively cheaply, at around $90,000 apiece. "We're dedicated to bringing the price down for everybody, rather than doing some really big project that nobody can repeat," Church says.

He hopes the machines will greatly accelerate the process of producing novel microbes. LS9, a biofuels company based near San Francisco that was co-founded by Church, has said it hopes to use MAGE to engineer E. coli that can produce renewable fuels. Church and colleagues are also adapting the approach for use with other useful bacteria, including Shewanella, which can convert toxic metals such as uranium into an insoluble form, and cyanobacteria which can extract energy from light using photosynthesis.

A big revolution

In principle, the technique should work with plant and animal cells as well as microbes. New methods will have to be developed for coaxing cells to swap in tailored DNA for each type of organism, but Church and his colleagues say that progress has already been made in yeast and mammalian cells.

"I think it is a big revolution in genome engineering," says Kristala Jones Prather, a bioengineer at the Massachusetts Institute of Technology who is not part of Church's collaboration. "You don't have to already know what the answer is. You can manipulate multiple things at a time, and let the cell find a solution for you."

Because biological systems are so complex, it is a huge advantage to be able to tweak lots of genes simultaneously, rather than one at a time, she says. "In almost every case you'll get a different solution that's a better solution."

The disadvantage of Church's approach is that the "better solution" is mixed up with millions of poorer solutions. Prather points out that the technique is limited by how easy it is to screen for the characteristics that you want. Wang selected good lycopene producers by growing 100,000 of the strains he had created in culture dishes and simply picking out the brightest red colonies. "Essentially nothing that we use in my lab can be screened so easily," Prather says.

By automating selection and using a few tricks, though, it should be practical to screen for far more subtle characteristics. For instance, biosensors that light up when a particular substance is produced could be built into the starting strain. "The power going forward will have to do with clever selections and screens," says Church.

As revolutionary as this approach is, Church thinks MAGE's most far-reaching potential lies elsewhere. He reckons it will be possible to use the evolution machine to make many thousands of specific changes to a cell's DNA: essentially, to rewrite genomes.

At the moment, making extensive changes to even the smallest genome is extremely costly and laborious. Last year, the biologist and entrepreneur Craig Venter announced that his team had replaced a bacterium's genome with a custom-written one (Science, vol 329, p 52). His team synthesised small pieces of DNA with a specific sequence, and then joined them together to create an entire genome. It was an awesome achievement, but it took 400 person-years of labour and cost around $40 million.

MAGE can do the same job far more cheaply and efficiently by rewriting existing genomes, Church thinks. The idea is that instead of putting DNA strands into the machine with a range of different mutations, you add only DNA with the specific changes you want. Even if you are trying to change hundreds or thousands of genes at once, after a few cycles in the machine, a good proportion of the cells should have all the desired changes. This can be checked by sequencing.

If the idea works it would make feasible some visionary projects that are currently impossibly difficult. Church, needless to say, has something suitably ambitious in mind. In fact, it is the reason he devised MAGE in the first place.

In 2004 he had joined forces with Joseph Jacobson, an engineer at the MIT Media Lab, best known as inventor of the e-ink technology used in e-readers. Searching for a "grand goal" in bioengineering, the pair hit upon the idea of altering life's genetic code. Rather than just alter the sequence of DNA, they want to change the very language in which the instructions for life are written(see diagram).

This is not as alarming as it might sound. Because all existing life uses essentially the same genetic code, organisms that translate DNA using a different code would be behind a "genetic firewall", unable to swap DNA with any normal living thing. If they escaped into the wild, they would not be able to spread any engineered components. Nor would they be able to receive any genes from natural bacteria that would endow them with antibiotic resistance or the ability to make toxins. "Any new DNA coming in or any DNA coming out doesn't work," says Church. "We're hoping that people who are concerned, including us, about escape from industrial processes, will find these safer."

There is another huge advantage: organisms with an altered genetic code would be immune to viruses, which rely on the protein-making machinery of the cells they infect to make copies of themselves. In a cell that uses a different genetic code, the viral blueprints will be mistranslated, and any resulting proteins will be garbled and unable to form new viruses.

Doing this in bacteria or cell lines used for growing chemicals would be of huge importance to industry, where viral infections can shut down entire production lines. And the approach is not necessarily limited to single cells. "It's conceivable that it could be done in animals," says Carr.

Completely virus-proof

Carr and his colleagues have already begun eliminating redundant codons from the genome of E. coli. They are starting with the rarest, the stop codon TAG, which appears 314 times. Each instance will be replaced by a different stop codon, TAA. So far they have used MAGE to create 32 E. coli strains that each have around 10 of the necessary changes, and are now combining them to create a single strain with all the changes. Carr says this should be completed within the next few months, after which he hopes to start replacing another 12 redundant codons. To make a bacterium completely virus-proof will probably require replacing tens of thousands of redundant codons, he says, as well as modifying the protein-making factories so they no longer recognise these codons.

To ensure novel genes cannot be translated if they get passed on to other organisms, the team would have to go a step further and reassign the freed-up codons so a different amino acid to normal is added to a protein when they occur. This could include amino acids that do not exist in nature, opening the door to new types of chemistry in living cells. Artificial amino acids could be used to create proteins that do not degrade as easily, for example, which could be useful in industry and medicine.

There are potential dangers in making organisms virus-proof, though. Most obviously, they might have an advantage over competing species if they escaped into the wild, allowing them to dominate environments with potentially destructive effects. In the case of E. coli, those environments could include our guts.

"We want to be very careful. The goal is to isolate these organisms from part of the natural sphere with which they normally interact," says Carr. "We shouldn't pretend that we understand all possible ramifications, and we need to study these modified organisms carefully." But he points out that we deal with similar issues already, such as invasive species running riot in countries where they have no natural predators. Additional safeguards could be built in, such as making modified organisms dependent on nutrients they can get only in a lab or factory. And if the worst came to the worst, biologists could create viruses capable of killing their errant organisms. Such viruses would not be able to infect normal cells.

Church argues that with proper safety and regulatory controls, there is no reason why the approach shouldn't be used widely. "I think that to some extent you'd like every organism to be multi-virus resistant," he says. "Or at least industrial microbes, agricultural species and humans."

Yes, humans. Church is already adapting MAGE for genetically modifying human stem cell lines. The work, funded by the US National Human Genome Research Institute, aims to create human cell lines with subtly different genomes in order to test ideas about which mutations cause disease and how. "Sequencing is now a million times cheaper, and there are a million times as many hypotheses being generated," he says. "We'd like to develop the resources so that people can quickly test hypotheses about the human genome by synthesising new versions."

As the technology improves and becomes routine, says Church, it could also be used to alter the cells used for cell-based therapies. Tissue-engineered livers grown from stem cells, say, could have their genetic code altered so that they would be immune to liver-destroying viruses such as hepatitis C.

"Everybody getting stem cell therapies will be given a choice of doing ordinary stem cell therapy - either with their cells or donor cells - or doing stem cells that are resistant to viruses," he says. "There will have to be all kinds of safety checks and FDA approval and so forth, but most people faced with two fairly safe choices, one of which is virus-sensitive and one of which is virus-resistant, are going to take the virus-resistant one."

Of course, there would be enormous experimental and safety hurdles to overcome. Not least the fact that gene targeting using homologous recombination or any other method is not perfect - the added DNA is sometimes inserted into the wrong place in the genome, and the process can trigger other kinds of mutations too. Such off-target changes might be a big problem when making hundreds of targeted changes at a time.

So not surprisingly, Carr describes the move to humans as "fraught with peril". But if we do get to a point where there are lots of people walking around with virus-resistant tissues or organs, and lots of farm animals that are completely virus-resistant, Church thinks it is only a matter of time before clinics create virus-resistant babies. "If it works really well, somebody somewhere will decide to try it in the next generation."

Making changes to the genomes of humans that will get passed on to their children has long been seen as taboo. But Church points out that there was strong resistance to techniques such as in vitro fertilisation and organ transplants when they were new; yet as soon as they were shown to work, they were quickly accepted. "Many technologies start out that way," he says. "But once they work really well, everybody says it's unethical not to use them."

Arthur Caplan, a bioethicist at the University of Pennsylvania in Philadelphia who advises the US government on reproductive technologies, is sceptical about the idea of making virus-resistant people, because anyone modified in this way would only be able to conceive children naturally with a partner whose genome had been altered in exactly the same way. "You would be denying a hugely important choice to a future modified human."

But, he says, if MAGE really can be used to edit the genome of human cells, it would provide a way to fix the mutations that cause inherited disease. It could be the technology that opens the door to the genetic engineering of humans. We should start debating now how best to use it, Caplan says. Should it be limited to preventing disease, or used for enhancement too? What sort of regulation is needed? Who should be eligible?

This prospect might seem a long way off, but Caplan argues that if the technique works well in other species, it could become feasible to attempt to engineer humans in as little as 10 years. "If you learn to do this in microbes and then in animals, you'll find yourself wondering how we got to humans so fast," he says. "You've got to pay attention to what's going on in lower creatures because that's the steady march to people."

If all this sounds wildly implausible, bear in mind that the idea of sequencing an entire human genome in days seemed nigh on impossible just a few years ago. Now it's fast becoming routine. Most biologists would probably agree that it is just a matter of time before we develop the technology needed to rewrite the DNA of living creatures at will. If Church succeeds, this future will happen faster than any imagined.

Trinity-FMW

2011-07-06T01:27:00.002+03:00

Regarding frameworks are undeniable the most loveable modules of comercial programming. The ability of using already-developed parts or even expand them to your needs is shared. Moreover, regarding software engineering frameworks are the sharping edge of the satellite. The way of developing abstract methods and classes and messing with the real implementation describes the magic of their use.
Trinity-FMW is a framework, which is developed in php and JQuery. It had been started as a personal attempt to bridge applications that need to connect with distributed server-side services such as Databases. This attempt were included features as PHP to server-side-services connection and interaction with the distributed client's application no matter what its developing features. This interaction were including XML, Port and HTTP GET/POST connection.
So as a client's application were following the interaction protocol Trinity-FMW could be the proxy-agent to serve any query. Though Trinity-FMW had implemented ways of connections with services in general, it was sharing the ability to the developer to expand its abilities and reach a more inductive implementation.
As the Abilities of the Trinity-FMW were expanding it reached the edge of its first developing purpose. Then Trinity-FMW had the ability to expand PHP in a better Object Oriented Programming (OOP) way. Since then it has a new goal to achieve, Trinity-FMW shares the ability to program in PHP with the Principles of Java's OOP.
As a Software Engineer I though that this is a great advantage of PHP since PHP's reaction time in serving the queries is really fast and OOP principles are the fetish of every OOP developer.
In addition, Trinity-FMW tries to implement abstract methods to result a better and easier AJAX applications by using the JQuery.
JQuery has the philosophy of Trinity_FMW. It tires to mess the Time-reaction abilities of Javascript with the OOP way of developing. This attempt results a bunch of applications that were really hard to be developed with a pure native code.

Furthermore, Trinity-FMW is shared as Open source. That is a personal decision wich were gained as I am an open source community member. Moreover, such attempt needs a lot of community's help in order to be achieved and release a stable version.
Trinity-FMW is hosted in git-hub and I would be really pleased if you could fork me.
More news to come regarding Trinity-FMW. Stay tuned :)
Trinity-FMW on Git-Hub

Lecture: Getting Computers To Learn, Part 4 of 4

2011-07-05T13:09:00.001+03:00

Lecture: Getting Computers To Learn, Part 3 of 4

2011-07-05T13:07:00.001+03:00

Lecture: Getting Computers To Learn, Part 2 of 4

2011-07-05T13:04:00.001+03:00

An introduction to machine learning, and some of the mathematics underlying machine learning algorithms.

Lecture: Getting Computers To Learn, Part 1 of 4

2011-07-05T13:01:00.001+03:00

An introduction to machine learning, and some of the mathematics underlying machine learning algorithms.

Q: According to relativity, two moving observers always see the other moving through time slower. Isn’t that a contradiction? Doesn’t one have to be faster?

2011-07-05T11:43:00.001+03:00

Physicist: They definitely both experience time dilation. That is to say, they both see the other person moving through time slower (you will always see your own clock running normally, in all circumstances). The short resolution to the “paradox” is: if you’re flying past each other, and never come back to the same place again to compare clocks, what’s the problem? You may both observe the other person’s clock running slower, but that’s not a contradiction in any “physical sense”.

Of course if you do meet up again, then you’ve got the “twin paradox”, which still isn’t a problem (or a paradox). One of the most frustrating things about the universe is that there is no such thing as “absolute time“, which would allow you to say “who’s right”. If you could ask the universe “what time is it?” the universe’s best answer would be “that depends on who’s asking”. The universe is kind of a smart ass.

There’s a halfway decent explanation the twin paradox here: “Q: How does the twin paradox work?” and there’s a quarterway decent, possibly simpler, explanation of why movement makes time pass slower here: “Q: Why does going fast or being lower make time slow down?“. Personally, I think the question of this post is far more profound.

I should note here that the language physicists use makes the situation sound subjective; “the observer sees…”, “the person experiences…”, etc. However, none of the effects (covered in a minute) are due to observer based effects, like the delay caused by the time it takes light to get from place to place. Everything here is literal and physically real.

You don't see an event when it happens, you see it when the light from the event gets to you. But you can easily figure out when it did happen by dividing the distance to the event by C, giving you the time delay.

This diagram is pretty standard physicist fare. If you want to draw a picture of something happening in 4 dimensional spacetime, you just drop two of the spacial dimensions. So here, time is up, space is left/right, the red arrow is a person (it doesn’t have to be a person) sitting still and moving forward in time (like you’re doing right now, in all likelihood). The yellow triangle is a lightning strike (at the bottom) and the light expanding out from it. The picture should make sense; the longer after the lightning strike (the higher on the picture) the farther the light from the strike has traveled (wider to the left and right). “Lightning” is a common example of an event, because it hits in a definite place at a very definite time. Plus, (spoiler alert) lightning is bright so, unlike most small instantaneous things, it makes sense that everyone should be able to see them.

Now let’s say you’ve got two people; Alice, who likes to hang out by the train tracks, andBob, who likes to ride trains on said tracks.

A train car (light blue) moves to the right. Right when Alice and Bob are eye-to-eye the front and back of the train car are hit by lightning. This moment, that Alice calls "Now!", is the red line.

As the train, with Bob sitting in the exact center, passes Alice they high-five each other. Suddenly, both ends of the train are struck by lightning. Alice knows this because, verysoon after the lightning strikes, the light from them get to her. Being smart, she realizes that the strikes must have happened at the same time, because they happened equally far away from her, and the light took the same amount of time to get to her (see picture). Moreover, really milking her cleverness, she predicts that Bob will see the lightning bolt at the front of the train first, and the lightning bolt at the back of the train second (see picture, some more).

The speed of light, C, is an absolute. No matter where you are, or how fast you’re moving, C stays exactly the same. So Alice’s reasoning is completely solid, and she’s right when she says that the lightning bolts happened at the same time.

When you say that two things are “happening at the same moment”, or “happening now” you’re saying that they’re on the same spacetime plane, that I’ll call a “moment plane”. In the same way that a regular 2D plane is a big, flat subset of regular 3D space, the moment planes are big flat 3D subsets of 4D spacetime.

So the high five, the lightning strikes, and everything else in the universe at that moment, are all in the same “moment plane”. However, that doesn’t necessarily mean that everything in that plane happens at the same time (although they do for someone, in this case Alice).

Same situation from the perspective of the train. Bob sees the lightning at the front of the train first, and the lightning at the back of the train second, and can even figure out that Alice will see them at the same time. However, he disagrees with Alice about when things happen.

Around 1900 the Michelson Morley experiment (among others) was demonstrating that the speed of light seemed to be the same to everyone, regardless of whether or not they’re moving. Einstein’s great insight was “Hey everybody, if the speed of light seemsto be the same regardless of the observers movement, then maybe it really is?” He was a staggering genius. Also, he was exactly right.

So, Alice was right about Bob seeing the front bolt first, and the back bolt second. However, as far as Bob’s concerned, she was wrong about why. Using the same reasoning Alice did, he figures that the speed of light is fixed (whether or not you’re moving), and the distance from him to the front and back of the train is the same, so since he saw the front bolt before the back, it must have happened first. And he’s right. Moreover, he thinks that the reason that Alice saw both at the same time is that she’s moving to the left, away from the first bolt and toward the second (picture).

The first thing that most people say when the hear about the train thought experiment is “Isn’t the person on the tracks correct, since they really are sitting still?” Nope! The tracks may be bigger, but (as Dr. V. E. Kilmer discovered experimentally) there’s no physical way to say who’s moving and who’s not.

Both Alice and Bob are completely correct. What’s very strange is that the ideas we intuitively have about “nowness” are wrong. As soon as two people are moving with respect to each other, the set of points that they consider “now” are no longer the same (different moment planes). Alice’s “now” is the same red line above, but Bob’s sees it as “tilted”.

After all of that, what you should take away is: “a things’s moment planes tilts up in the direction of its movement” (picture above). If this is the first time you’ve seen this sort of stuff, you shouldn’t really believe any of it. Or at least, you shouldn’t have internalized it.

This stuff isn’t terribly complicated, but it is really mind-bending, so take a moment.

Physically tilted "nows" are difficult to wrap your mind around. To encourage the reader to pause or go back a little bit; consider the above.

Finally, to actually answer the question, imagine the situation from the point of view of someone in between Alice and Bob, who sees them flying off at equal speeds in opposite directions. This puts Alice and Bob on equal footing, and there’s no questions about “who’s right” or “who’s moving”.

Alice and Bob's now planes at various times. If you were to ask Alice "how much time has passed for Bob now?" the answer will always be "less time than for Alice." The situation with Bob is exactly symmetrical.

Since the moment planes of each person “tilts up in the direction of movement”, each person is always trailing behind the other in time. When they pass each other they each start their stopwatches. For that one moment they can agree that T=0 for both of them. But that’s where the agreement ends. If you ask Bob about what set of points in the universe (both position and time) correspond to T=7, he’ll have no trouble telling you. Specifically, he’ll tell you “right now my stopwatch reads ‘T=7′ and, F.Y.I., Alice’s stopwatch reads ‘T=5′”. Bob recognizes that this is because her clock is running slower, and he’s right. At least, he’s right in terms of how time is flowing for him.

If you were to run over to Alice at the moment that her stop watch reads 5 (using aTARDIS or something), she would say “right now my stopwatch reads ‘T=5′ and Bob’s reads ‘T=3.5′”. Also being clever, she realizes that this is because Bob’s clock is running slower, and she’s right. Notice she doesn’t say “T=7″. Once again, this is because they disagree on what “now” means, since their moment planes aren’t the same.

The first question that should be coming to mind is something like “Well, what’s reallyhappening?” or “How is time actually passing?”. Sadly, time is a strictly local phenomena. How it flows is determined (defined really) by relative position and relative velocity. That is to say, there is no “universal clock” that describes how time passes overall. The only reason that there seems to be some kind of universal clock is that we (people) are all moving at very nearly the same speed. Or equivalently, we’re all sitting still in very much the same way. Our time, length, and speed scale are all just too small.

0^0 = ? ( Zero raised to the zeroth power ) equal? dilemma

2011-07-05T11:38:00.001+03:00

Clever student:

I know!

= = = = .

Now we just plug in x=0, and we see that zero to the zero is one!

Cleverer student:

No, you’re wrong! You’re not allowed to divide by zero, which you did in the last step. This is how to do it:

= = = =

which is true since anything times 0 is 0. That means that

= .

Cleverest student :

That doesn’t work either, because if then

so your third step also involves dividing by zero which isn’t allowed! Instead, we can think about the function and see what happens as x>0 gets small. We have:

So, since = 1, that means that = 1.

High School Teacher:

Showing that approaches 1 as the positive value x gets arbitrarily close to zero does not prove that . The variable x having a value close to zero is different than it having a value of exactly zero. It turns out that is undefined. does not have a value.

Calculus Teacher:

For all , we have

Hence,

That is, as x gets arbitrarily close to (but remains positive), stays at .

On the other hand, for real numbers y such that , we have that

Hence,

That is, as y gets arbitrarily close to , stays at .

Therefore, we see that the function has a discontinuity at the point . In particular, when we approach (0,0) along the line with x=0 we get

but when we approach (0,0) along the line segment with y=0 and x>0 we get

Therefore, the value of is going to depend on the direction that we take the limit. This means that there is no way to define that will make the function continuous at the point .

Mathematician: Zero raised to the zero power is one. Why? Because mathematicians said so. No really, it’s true.

Let’s consider the problem of defining the function for positive integers y and x. There are a number of definitions that all give identical results. For example, one idea is to use for our definition:

where the y is repeated x times. In that case, when x is one, the y is repeated just one time, so we get

= .

However, this definition extends quite naturally from the positive integers to the non-negative integers, so that when x is zero, y is repeated zero times, giving

which holds for any y. Hence, when y is zero, we have

Look, we’ve just proved that ! But this is only for one possible definition of . What if we used another definition? For example, suppose that we decide to define as

:= .

In words, that means that the value of is whatever approaches as the real number z gets smaller and smaller approaching the value x arbitrarily closely.

[Clarification: a reader asked how it is possible that we can use in our definition of , which seems to be recursive. The reason it is okay is because we are working here only with , and everyone agrees about what equals in this case. Essentially, we are using the known cases to construct a function that has a value for the more difficult x=0 and y=0 case.]

Interestingly, using this definition, we would have

= = =

Hence, we would find that rather than . Granted, this definition we've just used feels rather unnatural, but it does agree with the common sense notion of what means for all positive real numbers x and y, and it does preserve continuity of the function as we approach x=0 and y=0 along a certain line.

So which of these two definitions (if either of them) is right? What is really? Well, for x>0 and y>0 we know what we mean by . But when x=0 and y=0, the formula doesn't have an obvious meaning. The value of is going to depend on our preferred choice of definition for what we mean by that statement, and our intuition about what means for positive values is not enough to conclude what it means for zero values.

But if this is the case, then how can mathematicians claim that ? Well, merely because it is useful to do so. Some very important formulas become less elegant to write down if we instead use or if we say that is undefined. For example, consider thebinomial theorem, which says that:

where means the binomial coefficients.

Now, setting a=0 on both sides and assuming we get

= =

where, I've used that for k>0, and that . Now, it so happens that the right hand side has the magical factor . Hence, if we do not use then the binomial theorem (as written) does not hold when a=0 because then does not equal .

If mathematicians were to use , or to say that is undefined, then the binomial theorem would continue to hold (in some form), though not as written above. In that case though the theorem would be more complicated because it would have to handle the special case of the term corresponding to k=0. We gain elegance and simplicity by using .

There are some further reasons why using is preferable, but they boil down to that choice being more useful than the alternative choices, leading to simpler theorems, or feeling more "natural" to mathematicians. The choice is not "right", it is merely nice.

Source

Free Programming Books

2011-02-01T15:21:00.002+02:00

View Now >

I found this web page using StumbleUpon and thought you might enjoy it.

Free Programming Books

e-booksdirectory.com/programmi...

Don't forget to check out my favorite web pages and learn how you can use StumbleUpon to discover great content recommended just for you.

BagosGiAr sent you this page: OOPWeb.com - Data Structures and Algorithms by John Morris

2011-02-01T12:40:00.001+02:00

View Now >

I found this web page using StumbleUpon and thought you might enjoy it.

OOPWeb.com - Data Structures and Algorithms by John Morris

oopweb.com/Algorithms/Document...

Don't forget to check out my favorite web pages and learn how you can use StumbleUpon to discover great content recommended just for you.

- BagosGiAr

StumbleUpon is a discovery engine that finds the best of the web, recommended just for you. Learn more

If you do not wish to receive emails sent by StumbleUpon, please click here

On Line Index of Artificial Intelligence Journals

2011-01-28T15:28:00.002+02:00

View Now >

I found this web page using StumbleUpon and thought you might enjoy it.

On Line Index of Artificial Intelligence Journals

cs.iastate.edu/~honavar/aijour...

Don't forget to check out my favorite web pages and learn how you can use StumbleUpon to discover great content recommended just for you.

- BagosGiAr

StumbleUpon is a discovery engine that finds the best of the web, recommended just for you. Learn more

If you do not wish to receive emails sent by StumbleUpon, please click here

BagosGiAr sent you this page: Neural Network Tutorial

2011-01-28T15:09:00.001+02:00

View Now >

I found this web page using StumbleUpon and thought you might enjoy it.

Neural Network Tutorial

ai-junkie.com/ann/evolved/nnt1...

Don't forget to check out my favorite web pages and learn how you can use StumbleUpon to discover great content recommended just for you.

- BagosGiAr

StumbleUpon is a discovery engine that finds the best of the web, recommended just for you. Learn more

If you do not wish to receive emails sent by StumbleUpon, please click here