Vô Ngã

7/27/11

Turn off LCD 1.0

A small usefull software to help us turn the LCD right time you need.

http://www.redmondpie.com/downloadscenter/TurnOffLCDv101.zip

7/2/11

Using Microsoft Word 2010′s References Feature (for Students)

Writing essays can be a very daunting task. Brainstorming, drafting, researching, and referencing can sometime be unmanageable. Microsoft Word 2010′s reference function is a good productivity tool to manage citations and bibliography.

In this article we will show you how to create a reference list using Word 2010. We will also show you how to share you reference with your peers and how to create your own customized reference style.

Creating References

Microsoft Reference function is accessible from the reference tab.

Word 2010 comes with a list of default referencing style. Choose the referencing style that you want to use.

Click on the ‘Insert Citation’ button to open the add citation window.

Word 2010 allow us to add different source type such as ‘Journal Article’ for our essay.

Click on the insert citation button to view a list of your citation and click any of them to create an inline citation in your essay.

You can create a bibliography page by clicking on the ‘Bibliography’ button.

Sharing Your Reference List

Microsoft Word 2010 save your references under %APPDATA%MicrosoftBibliographySources.xml. Open your command line and type echo %APPDATA%. This will show you where windows store your APPDATA. In my case Microsoft Word 2010 store my reference list under
C:UserszainulAppDataRoamingMicrosoftBibliographySources.xml. Remember that this file will not exist unless you create a reference list.

You can copy this XML file to use your references in different computers. You can also copy other references into this XML file. We advise that you should back up Source.xml file periodically so you will not loose your reference list.

To merge other references into your reference list just copy any entry inside the into the other Source.xml file. Just make sure that the contains a unique value.

Creating Custom Reference Style

We can create our own referencing style by creating custom XSL files under ‘C:Program FilesMicrosoft OfficeOffice14BibliographyStyle’. For those with exceptional XSL skills you can read Microsoft Word 2010 blog to learn how to create custom referencing style.

One of the challenge in creating our own XSL file for Microsoft word is that the XSL file itself is quite complicated and it might just be more productive to download a set of custom reference style from bibword and place the content of the zip file under ‘C:Program FilesMicrosoft OfficeOffice14BibliographyStyle’ and restart your Microsoft Word. You should see some new reference style from your Word 2010.

Conclusion

Microsoft Word 2010 is a great editor that can help you to save time in creating references and citations. Microsoft Word 2010 Reference function is customizable and allows you to share your references with others.

6/12/11

SWT + JFace main library.

You can select multiple JAR files from this list by holding down the Ctrl key while clicking. Scroll down the list and select the remaining JAR files. The complete list for Eclipse 3.3 is shown below.
1. org.eclipse.core.commands_.jar
2. org.eclipse.equinox.common_.jar
3. org.eclipse.jface_.jar
4. org.eclipse.osgi_.jar
5. org.eclipse.ui.workbench_.jar
If there are any other JAR files that displayed for your Eclipse version when you looked at the JFace dependencies above, select them here as well. As mentioned earlier, org.eclipse.ui.workbench is not actually part of JFace but is included here because it supplies some useful dialog classes. When you have selected all of the required files, press OK. The Libraries tab should now show all of the JAR files, similar to the screenshot below.

6/8/11

PHP - Implementing Facebook Connect

Two weeks ago I took a look at Facebook Connect (FC) summarizing what it is and why developers would want to integrate it with their own applications in part 1 of this series. Originally I had thought this would be a two post topic but as I have learned more about FC I think it’s going to take a few posts to get up and running successfully. So, in this post we’re going to get all the pre-requisites out of the way and establish a connection with Facebook from our own application. We will then look at how we can do things with that connection in subsequent posts. Ready or not… let’s get started!

Getting Started

In order to use FC with your own application you first need to set your application up within Facebook so you can get your hands on an API key. As is the case when working with any API your API key will be used throughout your FC integration code for authentication purposes.

Step 1 – Add Facebook Developers to Your Applications

The first thing you need to do in order to set your application up within Facebook is add the Facebook Developers Application to your approved applications list. To do this, visit http://www.facebook.com/developers/. Once you have added the developers application to your authorized applications list you will have access to all the developer resources that Facebook has to offer as well as a discussion board for questions and issues.

Step 2 – Setup Your Application

Now that you have added the developers application to your authorized applications list you can now proceed with setting your application up.

Navigate back to the Facebook Developers application by visiting http://www.facebook.com/developers/ and click the Set Up New Application button at the top right of the window.

Now comes the fun part… setting up an application in Facebook involves a mega-form full of options and other required pieces of information. The form is fairly self-explanitory so I won’t take the time to go through it all with you. The only thing I will point out is the Connect tab. This section of the form concerns all the FC settings as they relate to your application. The only thing you need to concern yourself with at this point is the Base Domain field. “Specifying a base domain allows you to make calls using the PHP and JavaScript client libraries as well as get and store session information for any subdomain of the base domain.” Enter all the necessary information about your application and click Save Changes.

Establishing a Connection

Now that we have our API keys we can put the files in place that will help us establish a connection between our application and Facebook. I am having problems displaying code in my blog posts so for this post I’m just going to refer you to the FC getting started guide for the actual code to use. If any of you have any recommendations for tools to use to display code in WordPress blog posts I would love to hear them.

Step 1 – First the CCC File

The first thing we want to do is create something called the cross-domain channel communication (CCC) file. That’s an awfully big name for such a little file. Basically this file provides the Facebook JavaScript Client Library with what it needs in order to function properly.

Copy the code from the FC getting started guide located under #2 and paste it into a new file named xd_receiver.htm. This file needs to be placed in a directory that’s relative to the callback URL that you entered when setting up your application in the mega-form above. For those of you following along using CodeIgniter, you should be able to get away with placing this file in the root of your CI application. That’s where everything is really referenced from anyway regardless of the search engine friendly URLs.

Step 2 – Now the Test File

Now that we have the CCC file we can begin writing the file we are going to use to establish our connection. Since we are only testing things in this post we will just make a simple file that displays the Facebook log-in button and adds the application to the users approved applications list. Go ahead and create a new file named test.htm and then follow along with the getting started guide starting with #3 for the necessary markup. Again, for those CI users you can place this markup in a view file and load it using whatever template your program is using.

Before running the script you want to be sure to replace YOUR_API_KEY_HERE with your API key and with the appropriate path to the CCC file. Once you have done that you can upload the two files we’ve created and test.

That’s it!

When viewing your test file in a browser all you should see is a Connect button displayed. When you click the button you should see a pop-up window prompting you to either login to your Facebook account or give your application permission to access your profile like in the screen shot below:

Once you either login or give your application permission you can now go back to your Facebook account and look at the list of your authorized applications and you should now see your own application in the list.

What’s next?

We didn’t get into much of the real nitty gritty in this post but we did lay the ground work for what is to come. In the next post I will begin looking at how we can access information about our users from Facebook and how we can send data back. Stay tuned!

6/7/11

Switch to Google Apps

Top ten advantages of Google's cloud

Compared to on-premises, hosted and "software plus services" technologies, Google's multi-tenant, Internet-scale infrastructure offers faster access to innovation, superior reliability and security, and maximum economies of scale.

Begin Free Trial

6/4/11

TCPView v3.04

TCPView is a Windows program that will show you detailed listings of all TCP and UDP endpoints on your system, including the local and remote addresses and state of TCP connections. On Windows Server 2008, Vista, and XP, TCPView also reports the name of the process that owns the endpoint. TCPView provides a more informative and conveniently presented subset of the Netstat program that ships with Windows. The TCPView download includes Tcpvcon, a command-line version with the same functionality.

Using TCPView

When you start TCPView it will enumerate all active TCP and UDP endpoints, resolving all IP addresses to their domain name versions. You can use a toolbar button or menu item to toggle the display of resolved names. On Windows XP systems, TCPView shows the name of the process that owns each endpoint.

By default, TCPView updates every second, but you can use the Options|Refresh Rate menu item to change the rate. Endpoints that change state from one update to the next are highlighted in yellow; those that are deleted are shown in red, and new endpoints are shown in green.

You can close established TCP/IP connections (those labeled with a state of ESTABLISHED) by selecting File|Close Connections, or by right-clicking on a connection and choosing Close Connections from the resulting context menu.

You can save TCPView's output window to a file using the Save menu item.

Using Tcpvcon

Tcpvcon usage is similar to that of the built-in Windows netstat utility:

Usage: tcpvcon [-a] [-c] [-n] [process name or PID]

-a	Show all endpoints (default is to show established TCP connections).
-c	Print output as CSV.
-n	Don't resolve addresses..

Microsoft TCPView KB Article

This Microsoft KB article references TCPView:

Download TCPView
(284 KB)

5/31/11

Deductive Databases

By staying with the simple data types, but adding recursion to this database language, one gets a language called (positive?) Datalog, which is the language underlying deductive databases. Deductive databases are an extension of relational databases which support more complex data modeling. In this section we will see how simple examples of deductive databases can be represented in Prolog, and we will see more of the limitations of Prolog.

A standard example in Prolog is a geneology database. An extensional relation stores the parent relation: parent(X,Y) succeeds with X and Y if X has parent Y. (Maybe do an example consisting of some English monarchs?) Given this parent relation, we can define the ancestor relation as follows:

    ancestor(X,Y) :- parent(X,Y).     ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y).

This says that X has ancestor Y if X has parent Y; and X has ancestor Y if there is a Z such that X has parent Z and Z has ancestor Y. Given a definition for the parent relation as follows:

parent(elizabeth_II, charles_??). etc.

we can query about ancestors, such as:

:- ancestor(elizabeth_II,X).

and find all of Queen Elizabeth's ancestors.

This works very nicely in Prolog, since the parent graph is (essentially) a tree. However, if we try the same definition of transitive closure for a graph that is not acyclic like a tree, we can be in trouble. Say we have a relation owes(X,Y) which indicates that X owes money to Y, and we want to define a predicate avoids(X,Y), meaning that X tries to avoid running into Y. The definition is that people avoid someone to whom they owe money, and they avoid anyone that someone to whom they owe money avoids:

avoids(X,Y) :- owes(X,Y). avoids(X,Y) :- owes(X,Z), avoids(Z,Y).

This definition has the same form as the ancestor definition. The problem here is that the owes relation may be cyclic. It is possible for Andy to owe money to Bill, Bill to own money to Carl and Carl to owe money to Bill:

owes(andy,bill). owes(bill,carl). owes(carl,bill).

and if we ask who Andy avoids:

| ?- avoids(andy,X).

we get:

| ?- avoids(andy,X).  X = bill;  X = carl;  X = bill;  X = carl;  X = bill;  X = carl;  X = bill; ....

an infinite loop.

If we would like to use Prolog as an engine for deductive databases, this shows up a serious problem: that a user can write a simple specification (using only atoms and variablse) and yet Prolog won't give an answer, but will wander off to (or toward) infinity. One couldn't afford to give such a system to a naive database user. There it is important that any query come back with some answer. Think of an SQL system that sometimes went into an infinite loop. It wouldn't be much used, and certainly not by naive users.

This problem of infinite looping is a well-known problem in Prolog and Prolog programmers learn to program around it. The usual fix is to add an extra argument to the avoids/2 predicate that keeps the list of people encountered in the process of finding the avoidees. Then if one of them is encountered again, the search is made to fail at that point, since it is known that all avoidees from that one have already been found. I.e.,

avoids(X,Y,L) :- owes(X,Y), \+ member(Y,L). avoids(X,Y,L) :- owes(X,Z), \+ member(Z,L), avoids(Z,Y,[Z|L]).

Here we've used the Prolog predicate member/2, and the Prolog builtin, \+, which implements not. \+ member(Y,L) succeeds just in case member(Y,L) fails, and fails if it succeeds. Now with this program and the corresponding query, we get:

| ?- avoids(andy,X,[]).  X = bill;  X = carl;  no | ?-

This fix works to avoid the infinite loop, but it sometimes has some undesirable properties. There are graphs for which the computation will be exponential in the number of arcs. Consider the case in which Andy owes money to Bill and Bob, and Bill and Bob owe money to Carl; Carl owes money to Dan and Dave, and Dan and Dave owe money to Evan; Evan owes money to Fred and Frank, and Fred and Frank owe money to George; and so on. The graph of the owes relation can be pictured as in Figure 2.2.

**Figure 2.2:** Graph on which Prolog is exponential
$\begin{figure}\centerline{\epsfbox{figures/expgraph.eps}} \end{figure}$