Research Reviews

Android Activity and task

2012-01-08T23:58:00.000-08:00

A task is a collection of activities that users interact with when performing a certain job. The activities are arranged in a stack (the "back stack"), in the order in which each activity is opened.
A task is a cohesive unit that can move to the "background" when users begin a new task or go to the Home screen, via the HOME key.

When the system stops one of your activities (such as when a new activity starts or the task moves to the background), the system might destroy that activity completely if it needs to recover system memory. The system's default behavior preserves the state of an activity when it is stopped. This way, when users navigate back to a previous activity, its user interface appears the way they left it. However, you can—and should—proactively retain the state of your activities using callback methods(onSaveInstanceState()), in case the activity is destroyed and must be recreated.

Mablab

2011-12-31T20:07:00.001-08:00

http://blog.163.com/zjg0202@126/blog/static/57519237200961798917/

svn commands

2011-12-29T01:00:00.000-08:00

1. Check updated uncommit local files
svn status -u

SVG

2011-12-19T06:54:00.000-08:00

How to change text in SVG via external javascript

var elem = document.getElemetById("textElem"); // Assuming textElem is the id of text object in SVG.
textElem.firstChild.nodeValue = "Nex Text Here";

How the SVG was loading the javascript. Assuming WebKit-based browsers, I had to link the external javascript file from inside the SVG, not the HTML document (which wouldn't work). In HTML, I used:


//Then inside the SVG file, I linked the js file, and added an onload event, which happens after parsing, before rendering:

<_script xlink:href="test.js" type="text/ecmascript" encoding="utf-8"/>

Then inside the javascript file:


function init(evt) {
// sample call
     changeText("change my text");

}

function changeText(value) {
    var svgText;
    svgText = document.getElementById("varMyData").firstChild;
    svgText.nodeValue = value;
}

Session management

2011-11-26T21:44:00.001-08:00

There are three widely used methods for maintaining sessions in web environment: URL arguments, hidden form fields and cookies. While each of them has its benefits and shortcomings, cookies have proven to be the most convenient and also the least insecure of the three.

The "storage" of session IDs and the associated session data (user name, account number, etc.) on the web server is accomplished using a variety of techniques including, but not limited to: local memory, flat files, and databases.

To mitigate this particular threat (though not the XSS problem in general), many web applications tie session cookies to the IP address of the user who originally logged in, and only permit that IP to use that cookie. This is effective in most situations (if an attacker is only after the cookie), but obviously breaks down in situations where an attacker spoofs their IP address, is behind the same NATed IP address or web proxy—or simply opts to tamper with the site or steal data through the injected script, instead of attempting to hijack the cookie for future use.

Foundations of Security

2011-11-26T21:30:00.001-08:00

Foundations of Security: What Every Programmer Needs to Know

Chapter 7 Client-State Manipulation
To be secure, web applications should not trust clients, and should validate all input received from clients.

Cross-site scripting
Cross-site scripting (XSS) is a type of computer security vulnerability typically found in Web applications that enables attackers to inject client-side script into Web pages viewed by other users.
The non-persistent (or reflected) cross-site scripting vulnerability is by far the most common type. These holes show up when the data provided by a web client, most commonly in HTTP query parameters or in HTML form submissions, is used immediately by server-side scripts to generate a page of results for that user, without properly sanitizing the request.
A classic example of a potential vector is a site search engine: if one searches for a string, the search string will typically be redisplayed verbatim on the result page to indicate what was searched for. A reflected attack is typically delivered via email or a neutral web site.
The persistent (or stored) XSS vulnerability is a more devastating variant of a cross-site scripting flaw: it occurs when the data provided by the attacker is saved by the server, and then permanently displayed on "normal" pages returned to other users in the course of regular browsing, without proper HTML escaping. A classic example of this is with online message boards where users are allowed to post HTML formatted messages for other users to read.

Open new thread in Tomcat

2011-11-09T00:37:00.000-08:00

To open new thread to handle the time consuming task in Tomcat may have several method:

1. JMS
Maybe JMS is what you really looking for however it requires extra effort to use that on Tomcat because it is only Servlet Container(Tomcat is not a JEE container, but just a Servlet Container). You may eigher switch to real AppServer like Glassfish or JBoss or add JMS functionality to Tomcat by your own.
http://blogs.captechconsulting.com/blog/jairo-vazquez/tomcat-and-jms

2. Create a ServletContextListener to maintain the background thread by yourself or use ExecutorService
ServletContextListener is registered in web.xml and will be called when your app is started or stopped. You can then created (and later stop) your Thread, using the normal Java ways to create a Thread (or ExecutionService).

http://stackoverflow.com/questions/1194315/tomcat-background-threads
http://stackoverflow.com/questions/791986/background-thread-for-a-tomcat-servlet-app
http://stackoverflow.com/questions/4907502/running-a-background-java-program-in-tomcat

Node.js

2011-11-06T01:25:00.000-07:00

Node's stated number one goal is "to provide an easy way to build scalable network programs". What's the issue with current server programs? Let's do the math. In languages like Java™ and PHP, each connection spawns a new thread that potentially has an accompanying 2 MB of memory with it. On a system that has 8 GB of RAM, that puts the theoretical maximum number of concurrent connections at about 4,000 users. As your client-base grew, if you wanted your web application to support more users, you had to add more and more servers. Of course, this adds to a business's server costs, traffic costs, labor costs, and more. Adding to those costs are the potential technical issues — a user can be using different servers for each request, so any shared resources have to be shared across all the servers. For all these reasons, the bottleneck in the entire web application architecture (including traffic throughput, processor speed, and memory speed) was the maximum number of concurrent connections a server could handle.

Node solves this issue by changing how a connection is made to the server. Instead of spawning a new OS thread for each connection (and allocating the accompanying memory with it), each connection fires an event run within the Node engine's process. Node also claims that it will never deadlock, since there are no locks allowed, and it doesn't directly block for I/O calls. Node claims that a server running it can support tens of thousands of concurrent connections.

Node itself runs V8 JavaScript. The V8 JavaScript engine is the underlying JavaScript engine that Google uses with their Chrome browser. JavaScript is a great language for event-driven programming, because it allows anonymous functions and closures, and more importantly, the syntax is familiar to nearly everyone who has ever coded. The callback functions that are called when an event occurs can be written in the same spot where you capture the event.

Node is extremely well-designed for situations where you are expecting a high amount of traffic and the server-side logic and processing required isn't necessarily large before responding to the client. Here are some good examples of where Node would excel:

A RESTful API
A web service that provides a RESTful API takes in a few parameters, interprets them, pieces together a response, and flushes a response (usually a relatively small amount of text) back to the user . This is an ideal situation for Node, because it can be built to handle tens of thousands of connections. It also doesn't require a large amount of logic, and basically just looks up values from a database and pieces together a response. Since the response is a small amount of text, and the incoming request is a small amount of text, the traffic volume isn't high, and one machine can likely handle the API demands of even the busiest company's API.
Twitter queue
Think about a company like Twitter that has to receive tweets and write them to a database. There are literally thousands of tweets arriving every second, and the database can't possibly keep up with the number of writes required during peak usage times. Node becomes an important cog in the solution to this problem. As we've seen, Node can handle tens of thousands of incoming tweets. It can then quickly/easily write them to an in-memory Queuing mechanism (memcached for example), from which another separate process can write them to the database. Node's role in this is to quickly gather the tweet and pass this information off to another process responsible for writing it. Imagine another design — a normal PHP server that tries to handle writes to the DB itself — every tweet would cause a small delay as its written to the DB since the DB call would be blocking. A machine with this design may only be able to handle 2000 incoming tweets a second, due to the database latency. A million tweets a second, and you're talking 500 servers. Node, instead, handles every connection and doesn't block, enabling it to capture as many tweets as can be thrown at it. A node machine able to handle 50,000 tweets a second, and you're talking only 20 servers.
Video game statistics
If you've ever played a game like Call of Duty online, some things stick out at you immediately when you look at the game statistics, mainly that they must be tracking a TON of info about the game in order to produce that level of statistics. Then, factor in the millions of people playing the game at any point, and you realize there is a TON of information getting generated very quickly. Node is a good solution for this scenario, because it can capture the data getting generated from the games, do a minimal amount of consolidation on them, and then queue them up for writing to a database. It would seem silly to devote an entire server to tracking how many bullets people are firing in games, which might be the useful limit if you used a server like Apache, but it would seem less silly if instead you could devote a single server to tracking almost all the statistics from a game, like you might be able to do with a server running Node.

REST in Practice

2011-10-31T06:49:00.000-07:00

Access to a resource is always mediated by way of its representations. That is, web components exchange representations; they never access the underlying resource directly—the Web does not support pointers! URIs relate, connect, and associate representations with their resources on the Web. This separation between a resource and its representations promotes loose coupling between back-end systems and consuming applications. It also helps with scalability, since a representation can be cached and replicated.

Using content negotiation, consumers can negotiate for specific representation formats from a service. They do so by populating the HTTP Accept request header with a list of media types they’re prepared to process.

Taken together, verbs and status codes provide a general framework for operating on resources over the network.

REST describes the Web as a distributed hypermedia application whose linked resources communicate by exchanging representations of resource state.

The Web is no longer just a successful large-scale information system, but a platform for an ecosystem of services.

The Web Application Hacker’s Handbook

2011-10-26T08:46:00.000-07:00

Dafydd Stuttard, Marcus Pinto, Wiley Publishing, Inc.

The Core Security Problem: Users Can Submit Arbitrary Input to the server-side application.

The majority of attacks against web applications involve sending input to the server which is crafted to cause some event that was not expected or desired by the application’s designer.

Changing the price of a product transmitted in a hidden HTML form field, to fraudulently purchase the product for a cheaper amount.
Modifying a session token transmitted in an HTTP cookie, to hijack the session of another authenticated user.
Removing certain parameters that are normally submitted, to exploit a logic flaw in the application’s processing.
Altering some input that will be processed by a back-end database, to inject a malicious database query and so access sensitive data.

Bitnami Image installation on EC2

2011-09-22T09:10:00.000-07:00

http://bitnami.org/files/stacks/tomcatstack/6.0.33-0/README.txt
http://bitnami.org/stack/tomcatstack

Ubuntu Installation

2011-09-22T08:31:00.000-07:00

1. How to install and config SVN
http://www.subversionary.org/howto/setting-up-a-subversion-server-on-ubuntu-gutsy-gibbon-server
http://systhread.net/texts/200607subver.php
https://help.ubuntu.com/8.04/serverguide/C/subversion.html

2. How to install and config trac

3. How to install FTP Server
https://help.ubuntu.com/10.04/serverguide/C/ftp-server.html

Even Faster Web Sites

2011-09-11T00:15:00.000-07:00

Steve Souders -- O'Reilly

The Project Triangle: Fast, Good, Cheap. Pick two. predicts that under ideal circumstances, it is not possible to obtain fast, good and cheap. There must be a trade-off.

When looking at execution time, the place where programs spend most of their time is in loops. The return on optimization of code that is executed only once is negligible. The benefits of optimizing inner loops can be significant.

Adopting the YSlow rules can have a huge impact on the delivery time of web page.

Typically, however, the bottleneck is not JavaScript, but the DOM, so fiddling(摆弄) the scripts will have little effectiveness.

All browsers execute all JavaScript code in a page on a single thread(excepting the use of Web Sorkers).
If your JavaScript code takes longer than 0.1 seconds to execute, your page won't have that slick, snappy feel, if it take longer than 1 second, the application fees sluggish; longer than 10 second, and the user will be extremely frustrated.

Profilers Tool: Firebug for Firefox

Memory problem. You can do this in two ways:
User delete keyword to remove JavaScript objects that are no longer needed from memory.
Remove nodes that are no longer necessary from the web page DOM

Normally, most browsers download components in parallel, but that's not the case for external scripts. When the browser starts downloading an external script, it won't start any additional downloads until the script has been completely downloaded, parsed, and executed. IE 8 is the first browser that supports downloading scripts in parallel.

Typically, the page's onload event doesn't fire until all resources have been downloaded.

In many cases, a web page contains multiples scripts that have a particular dependency order. Using the normal SCRIPT SRC approach guarantees that the scripts are downloaded and executed in the order in which they are listed in th page.

Script Onload is the preferred technique for coupling asynchronously loaded external scripts with inline scripts.

Move Inline scripts to the bottom

To provide consistent behavior, browsers ensure that CSS is applied in the order specified(appear in the HTML document).

Write Efficient JavaScript
1. User Local Variables. In a function
var doc = document, ..... will be more efficient
use var keyword when assigning a variable value for the first. if not, it will treat as a global variable.

Comet is a term describing the collection of techniques, protocols, and implementations that address making low-latency data transit to the browser both viable and scalable. On the client side, the common techniques include polling, long polling, forever frame(iframe), XHR streaming and soon, WebSocket.

The server holds on to the request's connection by returning a Transfer-Encodeing: chunked or Connection: close response. When data is ready for a particular client or set of clients, those connections are identified and a response containing the payload is sent back to the browser. A toolkit such as Dojo Toolkit or a library such as js.io, can handle many of these complexities for your automatically.

However, both polling and long polling introduce a new problem for traditional web servers that are not optimized to handle large numbers of long held or long-lived connections, but rather5 are optimized to open and close connections as quickly as possible. Apache, for example, is designed to handle approximately 10, 000 simultaneous connections per server, whereas a s good Comet server should be able to handle more than 50,000 long-held connections to be cost-effective in a delivering real-time applications. Please refer Comet Maturity Guide.

Long polling does not support cross-domain requests if teh browser does not support cross-domain XHR, but the forever-frame technique does at lease support cross-subdomain. XHR traditionally has a more restrictive security model than iframes or script tags that are included or inserted into a documents. JSONP polling allows cross-domain polling through the insertion of script tags for each new request rather than relaying on the XHR.

GIF is a palette image format (256 color). It is suitable for graphic rather than photo. It support binary type of transparency. it support animation.
JPEG is a lossy format. It is suitable for photo rather than graphic. it does not support transparency and animation.
PNG is both palette and true color format. it support full alpha transparency. it does not support cross browser animation.

Image optimization tools: PNGOUT, IptiPNG, PngOptimizer Jpegtran, ImageMagick

Some browser (IE6, 7) limit the number of parallel downloads to two per server. IE 8 and Firefox 3 increase this to six per server.

When downloading resources from a single domain is the bottleneck, splitting resources across multiple domain s speeds up the page by increasing the number of parallel downloads.
Browsers enforce the maximum connections per server constraint based on the hostname in the url, not the ip address to which it resolves.

HTTP/1.0 responses are returned as one block of data, the size of which is communicated in the Content-Length header. The browser needs to know the size of the data in order to know when the response ends.
HTTP/1.1 introuced the Transfer-Encoding: chunked response header. With chunked encoding, the HTML document can be returned in multiple blocks of data. Each chunk of the response starts with its own size indicator. This allows the browser to parse each chunk as soon as it arrives, resulting in a page that loads faster.

2011-09-09T01:54:00.001-07:00

1. How do we change emulator screen orientation to landscape or portrait?
Ctrl-F12 is the keyboard shortcut.

Android UI线程

2011-08-24T08:08:00.000-07:00

当一个程序第一次启动时，Android会同时启动一个对应的主线程（Main Thread），主线程主要负责处理与UI相关的事件。主线程通常又被叫做UI线程。在开发Android应用时必须遵守单线程模型的原则：Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。Android设置了一个5秒的超时时间，一旦用户的事件由于主线程阻塞而超过5秒钟没有响应，Android会弹出一个应用程序没有响应的对话框。

Android禁止其他子线程来更新由UI thread创建的试图。

Handler和Looper
AsyncTask

Regardless of whether or not you use AsyncTask, always remember these two rules about the single thread model:

Do not block the UI thread, and
Make sure that you access the Android UI toolkit only on the UI thread.
AsyncTask just makes it easier to do both of these things.

网摘-编程感悟

2011-08-11T06:42:00.000-07:00

对所做的事情的理解越深，你就会做的越好。
超级程序员跟那些平庸的、一般的程序员比起来，对自己要做的事情的理解要深的多的多。
对你的领域里的基础知识理解的越好，你就越容易提升到更高的层次。你对这一层次的知识理解的越好，你就更容易掌握下一层次，以此类推。

DevOps是一种一起讨论和一起工作的文化。开始DevOps，意味着开始了一场你的程序员和系统管理者的心态的转变。只有当人们愿意相互交谈，关心相互的工作时，你才能更多更快的创造商业价值。

代码审查

2011-08-11T06:35:00.000-07:00

在Google，没有程序，任何产品、任何项目的程序代码，可以在没有经过有效的代码审查前提交到代码库里的。

很显然：在代码提交前，用第二群眼睛检查一遍，防止bug混入。这是对其最常见的理解，是对代码审查的好处的最广泛的认识。但是，依我的经验来看，这反倒是它最不重要的一点。人们确实在代码审查中找到了bug。可是，这些在代码审查中能发现的绝大部分bug，很显然，都是微不足道的bug，程序的作者花几分钟的时间就能发现它们。真正需要花时间去发现的bug不是在代码审查里能找到的。

代码审查的最大的功用是纯社会性的。如果你在编程，而且知道将会有同事检查你的代码，你编程态度就完全不一样了。你写出的代码将更加整洁，有更好的注释，更好的程序结构——因为你知道，那个你很在意的人将会查看你的程序。没有代码审查，你知道人们最终还是会看你的程序。但这种事情不是立即发生的事，它不会给你带来同等的紧迫感，它不会给你相同的个人评判的那种感受。

还有一个非常重要的好处。代码审查能传播知识。在很多的开发团队里，经常每一个人负责一个核心模块，每个人都只关注他自己的那个模块。除非是同事的模块影响了自己的程序，他们从不相互交流。这种情况的后果是，每个模块只有一个人熟悉里面的代码。如果这个人休假或——但愿不是——辞职了，其他人则束手无策。通过代码审查，至少会有两个人熟悉这些程序——作者，以及审查者。审查者并不能像程序的作者一样对程序十分了解——但他会熟悉程序的设计和架构，这是极其重要的。

Java USB Programming

2011-07-27T02:34:00.000-07:00

http://libusbjava.sourceforge.net/wp/?page_id=8

http://javausbapi.blogspot.com/2010/05/java-usb-api.html

USB Programming on Mobile Platform

2011-07-26T23:01:00.000-07:00

Android
Until android 3.1, the USB API is provided.

Windows Mobile 7
Not support USB function.

Blackberry
The Blackberry provides the ability for programs to send and receive data over the USB port via named channels. On device there are two APIs which provide access. On the desktop PC side, Blackberry Desktop Manager APIs(COM) enable access of these USB channels.
http://www.netdirect.ca/software/packages/barry/rawchannel.php

Service-Oriented Architecture: Concepts, Technology, and Design

2011-07-26T05:28:00.000-07:00

Web services-driven SOA is succeeding traditional distributed architecture on a global scale.

"Service-oriented architecture" is a term that represents a model in which automation logic is decomposed into smaller, distinct units of logic. Collectively, these units comprise a larger piece of business automation logic. Individually, these units can be distributed.

Enterprise logic can be divided into two domains: business logic and application logic. Service-oriented principles can be applied to both.

Modularity of Web services

messages = units of communication
operations = units of work
services = units of processing logic (collections of units of work)
processes = units of automation logic (coordinated aggregation of units of work)

Reverse proxy

2011-07-22T00:07:00.001-07:00

In computer networks, a reverse proxy is a type of proxy server that retrieves resources on behalf of a client from one or more servers. These resources are then returned to the client as though it originated from the reverse proxy itself. While a forward proxy is usually situated between the client application (such as a web browser) and the server(s) hosting the desired resources, a reverse proxy is usually situated closer to the server(s) and will only return a configured set of resources.

Squid is a proxy server and web cache daemon. It has a wide variety of uses, from speeding up a web server by caching repeated requests; to caching web, DNS and other computer network lookups for a group of people sharing network resources; to aiding security by filtering traffic. Although primarily used for HTTP and FTP, Squid includes limited support for several other protocols including TLS, SSL, Internet Gopher and HTTPS.

Linux command

2011-07-12T07:13:00.001-07:00

http://www.ha97.com/book/unixtoolbox_zh_CN.html

High Performance Web Sites

2011-07-07T22:54:00.000-07:00

http://stevesouders.com/hpws/rules.php
http://developer.yahoo.com/performance/rules.html

Internet Security Best Practice

2011-06-30T19:43:00.001-07:00

http://developer.yahoo.com/security/

JQuery

2011-06-19T19:09:00.000-07:00

JSON vs JSONP

It's actually not too complicated...

Say you're on domain abc.com, and you want to make a request to domain xyz.com. To do so, you need to cross domain boundaries, a no-no in most of browserland.

The one item that bypasses this limitation is

Embeded System

2011-06-14T23:11:00.001-07:00

QNX is a commercial Unix-like real-time operating system, aimed primarily at the embedded systems market. The product was originally developed by Canadian company, QNX Software Systems, which was later acquired by BlackBerry-producer Research In Motion.

FOSS

2011-06-14T20:47:00.000-07:00

Free and open-source software (F/OSS, FOSS) or free/libre/open-source software (FLOSS) is liberally licensed to grant the right of users to use, study, change, and improve its design through the availability of its source code. This approach has gained both momentum and acceptance as the potential benefits have been increasingly recognized by both individuals and corporations.

Rapid application development (RAD) is a software development methodology that uses minimal planning in favor of rapid prototyping. The "planning" of software developed using RAD is interleaved with writing the software itself. The lack of extensive pre-planning generally allows software to be written much faster, and makes it easier to change requirements.

Vertical market

2011-06-06T23:32:00.000-07:00

A vertical market is a market which meets the needs of a particular industry: for example, a piece of equipment used only by semiconductor manufacturers. It is also known as a niche market.

A horizontal market is a market which meets a given need of a wide variety of industries, rather than a specific one: for example, word processing software

内嵌Web浏览器

2011-05-31T01:19:00.001-07:00

现在有很多程序在界面上都采用内嵌IE浏览器控件的方式，这样有几个好处：

界面设计与程序设计的解耦－说白了，美工精通的事，程序员很少有能精通的
界面的描述更方便和标准化－HTML，IT业者都知道的“秘密”，呵呵
更细粒度的模块划分－这对很多功能来说都可以做到更细粒度的控制，比如自动升级

当然，“天下没有免费的午餐”，这么做也要付出一些代价：

内存资源占用大－对于做共享软件的开发者，谁提这个他跟谁急
引入新的不稳定和不安全因素－IE稳定和安全？我看到盖茨先生笑了
当然，内嵌IE浏览器控件的方式还牵涉到界面的控制逻辑与底层操作之间的互动，前面我写过一篇《MFC或WTL嵌入webbrowser控件后的 Javascript、C++互操作》，介绍了大概的互操作方法。

32 and 64 Linux

2011-05-22T19:58:00.000-07:00

FAQ:
1. How can I tell if I'm running in 64-bit JVM or 32-bit JVM?

System.getProperty("sun.arch.data.model") 
System.getProperty("os.arch");
#
# on a 64-bit Linux box:
# "x86" when using 32-bit JVM
# "xmd64" when using 64-bit JVM

You can try on the command line:

java -d64 -version
If it's not a 64-bit version, you'll get a message that looks like:

This Java instance does not support a 64-bit JVM. Please install the desired version.

2. In LINUX determine if a .a library/archive 32-bit or 64-bit?
objdump seems like the best way:

objdump -f libfoo.a | grep ^architecture

VNC

2011-05-18T02:03:00.000-07:00

In computing, Virtual Network Computing (VNC) is a graphical desktop sharing system that uses the RFB(Remote FrameBuffer) protocol to remotely control another computer. It transmits the keyboard and mouse events from one computer to another, relaying the graphical screen updates back in the other direction, over a network.

The VNC protocol is pixel based. Although this leads to great flexibility (i.e. any type of desktop can be displayed), it is often less efficient than solutions that have a better understanding of the underlying graphic layout like X11 or desktop such as RDP. Those protocols send graphic primitives or high level commands in a simpler form (e.g. open window), whereas RFB just sends the raw pixel data.

Remote Desktop Protocol (RDP) is a proprietary protocol developed by Microsoft, which concerns providing a user with a graphical interface to another computer. The protocol is an extension of the ITU-T T.128 application sharing protocol. Clients exist for most versions of Microsoft Windows (including Windows Mobile), Linux, Unix, Mac OS X, Android, and other modern operating systems. By default the server listens on TCP port 3389.

Device driver

2011-05-03T23:39:00.000-07:00

Device drivers can be abstracted into logical and physical layers. Logical layers process data for a class of devices such as Ethernet ports or disk drives. Physical layers communicate with specific device instances.

In Linux environments, programmers can build device drivers either as parts of the kernel or separately as loadable modules.The Microsoft Windows .sys files and Linux .ko modules contain loadable device drivers. The advantage of loadable device drivers is that they can be loaded only when necessary and then unloaded, thus saving kernel memory.

Typically, the logical device driver (LDD) is written by the operating system vendor, while the physical device driver (PDD) is implemented by the device vendor.

Device drivers, particularly on modern Windows platforms, can run in kernel-mode (Ring 0) or in user-mode (Ring 3).The primary benefit of running a driver in user mode is improved stability, since a poorly written user mode device driver cannot crash the system by overwriting kernel memory. On the other hand, user/kernel-mode transitions usually impose a considerable performance overhead, thereby prohibiting user mode-drivers for low latency and high throughput requirements.

Kernel space can be accessed by user module only through the use of system calls. End user programs like the UNIX shell or other GUI based applications are part of the user space. These applications interact with hardware through kernel supported functions.

Linux Flavor

2011-04-28T22:56:00.000-07:00

http://www.testfreaks.com/blog/information/linux-bakers-dozen/

Flavors of UNIX:
http://middlewareforum.com/weblogic/?cat=15

Version 2 of Ravi’s Mind Map of Linux distributions。

下载高解析度1300 x 1078版本

Python

2011-04-26T19:57:00.001-07:00

Python is an interpreted, general-purpose high-level programming language[5] whose design philosophy emphasizes code readability.

Installation:
http://trac.edgewall.org/wiki/0.12/TracInstall
Install setuptools 0.6
http://pypi.python.org/pypi/setuptools

SVG

2011-04-25T01:19:00.001-07:00

SVG stands for Scalable Vector Graphics. SVG defines graphics in XML format. It is a language for describing 2D-graphics and graphical applications in XML.

The main competitor to SVG is Flash. The biggest advantage SVG has over Flash is the compliance with other standards (e.g. XSL and the DOM). Flash relies on proprietary technology that is not open source.

C++ Unicode

2011-04-19T00:37:00.000-07:00

_T("Text") is a narrow-character (ASCII) literal in an ANSI build but a wide character (UNICODE) literal in a Unicode build.
L"Text" is always a wide-character literal, regardless of preprocessor definitions.
_T() is a macro, the L prefix is part of the core C and C++ language lexical structure.

ref

http://stackoverflow.com/questions/402283/stdwstring-vs-stdstring

http://www.codeproject.com/KB/cpp/unicode.aspx
http://www.codeproject.com/KB/stl/upgradingstlappstounicode.aspx
http://www.vckbase.com/document/viewdoc/?id=1734

Java Code Obfuscator

2011-02-08T01:39:00.001-08:00

The Java programming language is particularly open to reverse-engineering attacks because of its well-defined, open, and portable binary format. One area of better-securing the intellectual property of a Java program is obfuscation.

Obfuscation of a program involves transforming the code of the program into a more complex, but semantically equivalent representation. This can include the addition of confusing control flow, the removal of certain information embedded in the program which is not explicitly required for execution, or the cloaking of data.

Open Source Obfuscators in Java(http://java-source.net/open-source/obfuscators)

ProGuard
yGuard
JODE
JavaGuard
RetroGuard
jarg

commercial Obfuscators in Java

Zelix Klassmaster

Advantages of Exceptions

2011-02-07T17:32:00.000-08:00

Advantage 1: Separating Error-Handling Code from "Regular" Code
Exceptions provide the means to separate the details of what to do when something out of the ordinary happens from the main logic of a program. In traditional programming, error detection, reporting, and handling often lead to confusing spaghetti code.

Advantage 2: Propagating Errors Up the Call Stack
A second advantage of exceptions is the ability to propagate error reporting up the call stack of methods.

Advantage 3: Grouping and Differentiating Error Types
Because all exceptions thrown within a program are objects, the grouping or categorizing of exceptions is a natural outcome of the class hierarchy.

Comparison of wireless communication

2011-02-06T16:42:00.000-08:00

Wireless Technology: Bluetooth, WiFi, WiMAX
http://www.awirelesslife.com/wireless.html
Bluetooth-WiFi-WiMAX
http://wenku.baidu.com/view/2609f68ecc22bcd126ff0ce1.html
Compare with other Technologies(bluetooth)
http://www.bluetooth.com/English/Technology/Works/Pages/Compare.aspx
How does ZigBee compare with other wireless standards?
http://www.stg.com/wireless/ZigBee_comp.html
http://gigaom.com/cleantech/the-race-is-still-on-zigbee-vs-wifi-for-smart-energy-homes/
http://panometric.net/zigbee-vs-wifi-smackdown/
http://www.emeter.com/2010/smart-appliances-wifi-vs-zigbee-communications-the-great-debate/

If Wifi can be in the same order of magnitude as Zigbee in battery life and cost, and mesh is an unneeded or easily added capability, Zigbee may not fly for being just another protocol.

Wireless sensors are most useful when their data ubiquitous, and all the other devices you want to use to display, notify, and interact are on IP networks. So WiFi has a huge advantage there in that it is IP friendly. In fact, I foresee a time when wireless sensor devices can use web services directly, rather than need application servers. Data analysis and messaging could be done in the cloud where it is reliable and manageable.

ZigBee
ZigBee-style networks began to be conceived around 1998, when many installers realized that both Wi-Fi and Bluetooth were going to be unsuitable for many applications. In particular, many engineers[by whom?] saw a need for self-organizing ad-hoc digital radio networks.

ZigBee protocols are intended for use in embedded applications requiring low data rates and low power consumption. ZigBee's current focus is to define a general-purpose, inexpensive, self-organizing mesh network that can be used for industrial control, embedded sensing, medical data collection, smoke and intruder warning, building automation, home automation, etc.

PLC
The PLC technology, which uses the electrical wiring of the house to transmit data, can be a complement to Wi-Fi then Exit barriers wall. In addition, it allows either to extend the reach of its Wi-Fi or secure data. Indeed, with LPG, the problems of network security are easier to manage because the electric meter acts as a filter. Moreover adapters often provide the encryption of data. The CPL boasts a range of 250 meter range and its implementation is very simple. Simply just plug the adapter into the outlet and connect it to the desired computer or your ISP's box by Ethernet cable.

After you have nothing to do, after a few minutes, the computer receives the signal and you can easily connect to the Internet.In general, CPL Kits deliver a theoretical throughput of 200 Mbit / s. In reality, it takes on a rate of 40 Mbit /s. It is quite enough to surf broadband and receive images in High Definition. Moreover, these kits allow CPL set priorities for use.

JSON

2011-01-31T17:50:00.001-08:00

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate.

JSON is built on two structures:

* A collection of name/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
* An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence.


{
     "firstName": "John",
     "lastName" : "Smith",
     "age"      : 25,
     "address"  :
     {
         "streetAddress": "21 2nd Street",
         "city"         : "New York",
         "state"        : "NY",
         "postalCode"   : "10021"
     },
     "phoneNumber":
     [
         {
           "type"  : "home",
           "number": "212 555-1234"
         },
         {
           "type"  : "fax",
           "number": "646 555-4567"
         }
     ]
 }

Since JSON is a subset of JavaScript, it is possible (but not recommended) to parse JSON text into an object by invoking JavaScript's eval() function. For example, if the above JSON data is contained within a JavaScript string variable contact, one could use it to create the JavaScript object p like so:


var p = eval("(" + contact + ")");

HTTPS

2011-01-27T00:23:00.000-08:00

Are https URLs encrypted?

HTTPS Establishes an underlying SSL conenction before any HTTP data is transferred. This ensures that all URL data (with the exception of hostname, which is used to establish the connection) is carried solely within this encrypted connection and is protected from man-in-the-middle attacks in the same way that any HTTPS data is.

From the outside the only data that is visible to the world it the hostname and port you are connecting to. Everything else is simply a stream of binary data which is enctypted using a private key shared only between you and the server.

So yes. The data contained in the URL query on an HTTPS connection is encrypted. However it is very poor practice to include such sensitive data as a password in the a 'GET' request. While it cannot be intercepted, the data would be logged in plaintext serverlogs on the receiving HTTPS server, and quite possibly also in browser history. It is probably also available to browser plugins and possibly even other applications on the client computer. At most an HTTPS URL could be reasonably allowed to include a session ID or similar non-reusable variable.

REST

2011-01-17T23:20:00.000-08:00

Representational state transfer (REST) is a style of software architecture for distributed hypermedia systems such as the World Wide Web.

It is possible to claim an enormous number of RESTful applications on the Web (just about everything accessible through an HTTP GET request or updateable through HTTP POST)

Various websites and web applications offer REST-like developer interfaces to data (e.g. Flickr or Amazon S3).

REST uses HTTP for all four CRUD (Create/Read/Update/Delete) operations.

As a rule, GET requests should be for read-only queries; they should not change the state of the server and its data. For creation, updating, and deleting data, use POST requests. (POST can also be used for read-only queries, as noted above, when complex parameters are required.)

While REST services might use XML in their responses (as one way of organizing structured data), REST requests rarely use XML.

As shown above, in most cases, request parameters are simple, and there is no need for the overhead of XML.

More precisely, a Web service is a Web page that’s meant to be consumed by an autonomous program as opposed to a Web browser or similar UI tool

Resources are identified by uniform resource identifiers (URIs)
Messages are self-descriptive and stateless

A Web-based application is a dynamically changing graph of
– state representations (pages)
– potential transitions (links) between states

There are no applications you can think of which cannot be made to fit into the GET / PUT / POST /DELETE resources / representations model of the world!

Multiple POSTs of the same data must be made harmless
Put some kind of message ID in a header or in the message body

“POST lets you pass a whole lot of parameters and get something back, bypassing caches.”

It is a common convention in REST design to use nouns rather than verbs to denote simple resources.
As a rule, GET requests should be for read-only queries; they should not change the state of the server and its data. For creation, updating, and deleting data, use POST requests. (POST can also be used for read-only queries, as noted above, when complex parameters are required.)

One advantage of using XML is type safety. However, in a stateless system like REST, you should always verify the validity of your input, XML or otherwise!

A server response in REST is often an XML file. However, other formats can also be used; unlike SOAP services, REST is not bound to XML in any way. Possible formats include CSV (comma-separated values) and JSON (JavaScript Object Notation).
Each format has its own advantages and disadvantages. XML is easy to expand (clients should ignore unfamiliar fields) and is type-safe; CSV is more compact; and JSON is trivial to parse in JavaScript clients (and easy to parse in other languages, too).

One option is not acceptable as a REST response format, except in very specific cases: HTML, or any other format which is meant for human consumption and is not easily processed by clients.
http://rest.elkstein.org/

REST 5 principles:

Give every “thing” an ID
Link things together
Use standard methods
Resources with multiple representations
Communicate statelessly

Architecture review

2010-12-08T00:26:00.001-08:00

A Swing Architecture Overview
http://java.sun.com/products/jfc/tsc/articles/architecture/
It is generally considered good practice to center the architecture of an application around its data rather than around its user interface.

QT

2010-10-19T23:11:00.001-07:00

http://blog.csdn.net/huihui1988/archive/2010/09/12/5879211.aspx

Linux Programming

2010-10-19T19:07:00.000-07:00

CMake is used to control the software compilation process using simple platform and compiler independent configuration files. CMake generates native makefiles and workspaces that can be used in the compiler environment of your choice.

A cross compiler is a compiler capable of creating executable code for a platform other than the one on which the compiler is run. Cross compiler tools are used to generate executables for embedded system or multiple platforms. It is used to compile for a platform upon which it is not feasible to do the compiling, like microcontrollers that don't support an operating system.

Compiling
-fPIC: Position Independent Code

How to create a shared library.
http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html

Error:
1. linker error - linker input file unused
When you use -c flag, i.e. no linking is done, the input is C++ code, and the output is object code. The .o files thus don't mix with -c, and compiler warns you about that.

PROG ?= myprog
OBJS = worker.o main.o

all: $(PROG)

.cpp.o:
        g++ -Wall -pedantic -ggdb -O2 -c -o $@ $<

$(PROG): $(OBJS)
        g++ -Wall -pedantic -ggdb -O2 -o $@ $(OBJS)

USB Programming

2010-10-17T20:19:00.000-07:00

USB connects several devices to a host controller through a chain of hubs. In USB terminology, devices are referred to as functions, because each individual physical device may actually host several functions.These devices/functions (and hubs) have associated pipes (logical channels). The pipes are synonymous to byte streams such as in the pipelines of Unix. Pipes are connections from the host controller to a logical entity on the device named an endpoint.These endpoints (and their respective pipes) are numbered 0-15 in each direction, so a device/function can have up to 32 active pipes, 16 into the host controller and 16 out of the controller.Each endpoint can transfer data in one direction only, either into or out of the device/function, so each pipe is uni-directional.

The pipes are also divided into four different categories by way of their transfer type:
    * control transfers - typically used for short, simple commands to the device, and a status response, used e.g. by the bus control pipe number 0
    * isochronous transfers - at some guaranteed speed (often but not necessarily as fast as possible) but with possible data loss, e.g. realtime audio or video
    * interrupt transfers - devices that need guaranteed quick responses (bounded latency), e.g. pointing devices and keyboards
    * bulk transfers - large sporadic transfers using all remaining available bandwidth (but with no guarantees on throughput or latency), e.g. file transfers

The device descriptor of a USB device has a signature that tells what kind of device has been attached to the bus. This signature consists of class code, subclass code and protocol fields. Together, these identify what operating system driver should be used to communicate with the device.

Devices that attach to the bus can be full-custom devices requiring a full-custom device driver to be used, or may belong to a device class. These classes define an expected behavior in terms of device and interface descriptors so that the same device driver may be used for any device that claims to be a member of a certain class.

Reference:
http://blog.163.com/lyzaily@126/blog/static/4243883720096101044126/

Mobile widget

2010-07-26T01:49:00.000-07:00

Opera Widget

What are widgets?

Widgets are Web applications running on your desktop. They are implemented using client-side Web technologies, and creating one is very much like creating a Web page, except that it is run in a slightly different context.
Opera browsers can install and open these widgets, showing them directly on the user’s desktop (or equivalent in other devices). Widgets are native applications created with web standards, which can integrate nicely with your computer or device.

Packaging widgets

Opera Widgets are packaged as regular zip files, renamed to use the extension .wgt. All the files related to your widget should be stored inside the widget file. A typical widget contains the following elements:

A widget configuration file — config.xml. This is an XML file in the root of the widget structure that holds information about your widget including its size, name, author, and security information.
An index document — index.html. Like on a Web page, this document contains the basic skeleton/content of the widget. Widgets content can be created using any markup that Opera handles natively, for example HTML, SVG, or XML files. This file also lives in the root of the widget structure.
Images. These are contained in a single images folder.
JavaScript files. These are contained in a single script folder.
Style sheets. These are contained in a single style folder.

BlackBerry Widget
BlackBerry Widgets are small, discrete, standalone web applications that use HTML, CSS and JavaScript®. They look, behave and have the same security mechanisms as a native BlackBerry smartphone application. BlackBerry Widgets can be installed on a BlackBerry smartphone like any native BlackBerry smartphone application and extended to use device-specific information and data with BlackBerry Widget APIs.

Android Widget
App Widgets are miniature application views that can be embedded in other applications (such as the Home screen) and receive periodic updates. These views are referred to as Widgets in the user interface, and you can publish one with an App Widget provider. An application component that is able to hold other App Widgets is called an App Widget host. The screenshot below shows the Music App Widget.

Qt

2010-07-22T17:45:00.001-07:00

Qt is a cross-platform application development framework widely used for the development of GUI programs (in which case it is known as a widget toolkit), and also used for developing non-GUI programs such as console tools and servers. It is produced by Nokia's Qt Development Frameworks division. Non-GUI features include SQL database access, XML parsing, thread management, network support, and a unified cross-platform API for file handling.
Qt can also be used in several other programming languages via language bindings, such as java.

This connect() call establishes a one-way connection between two Qt objects. Every Qt object can have both signals (to send messages) and slots (to receive messages).

Older toolkits achieve this kind of communication using callbacks. A callback is a pointer to a function, so if you want a processing function to notify you about some event you pass a pointer to another function (the callback) to the processing function. The processing function then calls the callback when appropriate. Callbacks have two fundamental flaws: Firstly, they are not type-safe. We can never be certain that the processing function will call the callback with the correct arguments. Secondly, the callback is strongly coupled to the processing function since the processing function must know which callback to call.

The signals and slots mechanism is type safe: The signature of a signal must match the signature of the receiving slot. (In fact a slot may have a shorter signature than the signal it receives because it can ignore extra arguments.) Since the signatures are compatible, the compiler can help us detect type mismatches. Signals and slots are loosely coupled: A class which emits a signal neither knows nor cares which slots receive the signal. Qt's signals and slots mechanism ensures that if you connect a signal to a slot, the slot will be called with the signal's parameters at the right time. Signals and slots can take any number of arguments of any type. They are completely type safe.

All classes that contain signals or slots must mention Q_OBJECT at the top of their declaration. They must also derive (directly or indirectly) from QObject.

Qt Quick has been released with Qt 4.7. Companies use it to build user interfaces (UIs) for set-top boxes, tablet devices, in-vehicle infotainment systems, e-readers or mobile phones. It provides a declarative language QML (Qt Meta-object Language) for designing and implementing UIs. QML is based on CSS and JavaScript.

QBENCHMARK: Test the overhead of a function.

Java Advanced Topic

2010-06-27T19:31:00.001-07:00

Java Reflection API

Inner class
Inner class has access to any and all methods and members, even the parent's this reference. The advantages of inner classes can be divided into three categories: an object-oriented advantage, an organizational advantage, and a call-back advantage.

JavaFX

2010-05-18T18:55:00.001-07:00

JavaFX is a Java platform for creating and delivering rich Internet applications that can run across a wide variety of connected devices. The current release (JavaFX 1.3, April 2010) enables building applications for desktop, browser and mobile phones. TV set-top boxes, gaming consoles, Blu-ray players and other platforms are planned.

JavaFX builds on Java technology. To build JavaFX apps developers use a statically typed, declarative language called JavaFX Script; Java code can be integrated into JavaFX programs. JavaFX is compiled to Java bytecode, so JavaFX applications run on any desktop and browser that runs the Java Runtime Environment (JRE) and on top of mobile phones running Java ME.

JBed CDC

IBM J9

Midlet Manager

Digital Identity

2010-05-03T19:29:00.000-07:00

Information Card

SAML

OpenID

OAuth

XDI

Bluetooth

2010-04-27T23:23:00.000-07:00

Every Bluetooth device is assigned a unique Bluetooth address, being a 48-bit hardware address equivalent to hardware addresses assigned to regular Network Interface Cards (NICs).

Two types of physical links are defined in version 1.1 of the Bluetooth specification, Synchronous Connection Oriented (SCO) links and Asynchronous ConnectionLess (ACL) links.

SCO links are intended for audio transmission. When setting up a SCO link time slots are reserved for transmission of data, thus providing a Quality of Service (QoS) guarantee. Lost or erroneous packages are not re-transmitted which makes sense for voice transmissions.

ACL links are intended for data communication. An ACL link provides error-free transmission of data which means that lost or erronous packets are re-transmitted.

L2CAP provides multiplexing between different higher layer protocols over a single physical ACL link, enabling several logical data links to be set up between two Bluetooth devices. An ACL packet can have a maximum of 339 bytes of payload data, while an L2CAP packet can have a maximum of 65,535 bytes of payload data.

The RFCOMM layer emulates RS-232 serial ports and serial data streams. RFCOMM relies on L2CAP for multiplexing multiple concurrent data streams and handling connections to multiple devices. The majority of Bluetooth profiles make use of the RFCOMM protocol because of its ease of use compared to direct interaction with the L2CAP layer.

The Bluetooth Specification refers to the device discovery operation as inquiry. During the inquiry process the inquiring Bluetooth device will receive the Bluetooth address and clock from nearby discoverable devices.

Different Bluetooth devices offer different sets of services. Hence, a Bluetooth device needs to do a service discovery on a remote device in order to obtain information about available services. Service searches can be of a general nature by polling a device for all available services, but can also be narrowed down to find just a single service.

The Universally Unique IDentifier (UUID), is the data type used for identifying services, protocols and profiles etc. A UUID is a 128-bit identifier that is guaranteed to be unique across all time and space.

Bonding is the procedure of a Bluetooth device authenticating another Bluetooth device, and is dependent on a shared authentication key. If the devices do not share an authentication key, a new key must be created before the bonding process can complete. Generation of the authentication key is called pairing. The pairing process involves generation of an initialization key and an authentication key, followed by mutual authentication.

The authentication key is based on random numbers and Bluetooth addresses from both devices.

Storing the authentication key is useful for devices frequently connecting to each other, such as a laptop computer frequently connecting to the dial-up networking service on a cellphone. The bonding procedure can then complete without user input and the user is relieved of figuring out a new passkey every time he or she wants to connect to the Internet.

Paypal

2010-04-27T00:50:00.000-07:00

在支付完在之后，支付台平都会去调用你的IPN，其实大部分的开发者就是不了解IPN的意义，IPN是一个实时通知程序，支付平台在支付完成以后会通知你的网站，支付已经完成，如果完全利用一般IE的重定向来通知，用户可能在支付完成以后，立即关闭IE，这样就可能导致数据没有更新，而使用IPN就不会，就算服务器中断，支付平台也会不断的发请求，直到你的服务器回送处理完成为止。

Install Perl

2010-04-12T19:32:00.000-07:00

Bugzilla Installation steps:
http://www.bugzilla.org/docs/tip/en/html/installation.html
https://wiki.mozilla.org/Bugzilla:Win32Install#Install_2

Install Perl module:
build:
perl Makefile.PL
make
make test
install
make install

Config WebServer
/etc/httpd/conf/httpd.conf

/usr/sbin/apachectl start
/usr/sbin/apachectl stop
/usr/sbin/apachectl restart

FAQ
"Error installing package 'DBI': Could not > locate a PPD file for package DBI"
You may be behind a proxy/firewall. If so,

at the command prompt
SET HTTP_proxy=http://myproxy

LDAP

2010-04-06T23:29:00.000-07:00

The Lightweight Directory Access Protocol, or LDAP, is an application protocol for querying and modifying data using directory services running over TCP/IP. A directory is a set of objects with attributes organized in a logical and hierarchical manner. A simple example is the telephone directory, which consists of a list of names (of either persons or organizations) organized alphabetically, with each name having an address and phone number associated with it.

A client starts an LDAP session by connecting to an LDAP server, called a Directory System Agent (DSA), by default on TCP port 389. The client then sends an operation request to the server, and the server sends responses in return.

J2ME

2010-04-06T02:57:00.000-07:00

Basically there are two types of configurations involved in Java ME application development, which are:

CLDC (Connected Limited Device Configuration)
CDC (Connected Device Configuration)

Architecture The Java ME Architecture comprises of three software layers:
The first layer is the configuration layer that includes the JVM, which directly interacts with the native OS. The Configuration layer also handles the interaction between the profile and the JVM.

The second layer is the profile layer, which consists of the minimum set of application programming interface (API) for the small devices.

The main goal of the CLDC Specification is to standardize a highly portable minimum-footprint Java application development platform for resource-constrained, connected devices. CLDC defines a minimal subset of functionality from the J2SE platform. Hence, the CLDC does not define device-specific functionality.

In CLDC, GUI-libraries and the java.net library are unavailable. All packages are subsets of the corresponding packages from J2SE, except the javax.microedition.io package which is introduced in the CDLC. Java.io provides basic input and output streams, but not file streams or other libraries for persistent storage. Note that user interface, networking support and persistent storage are addressed by the MIDP.

The third layer is the Mobile Information Device profile (MIDP) layer. The MIDP layer contains java APIs for user network connections, persistence storage, and the user interface. It also has access to CLDC libraries and MIDP libraries.

MIDP 2.0 adds support for HTTPS, datagram, sockets, server sockets and serial port communication.

Push architecture is introduced in MIDP 2.0. This makes it possible to activate a MIDlet when the device receives information from a server. Hence, developers may develop event driven applications utilizing carrier networks. An example of this could be a SMS MIDlet, which would be activated when a new incoming SMS arrived at the device.

End-to-end security is provided by HTTPS and SSL/TLS protocol access over the IP (Internet Protocol) network. The ability to set up secure connections is a leap forward for MIDP programming. A wide range of application models require encryption of data and may now utilize the security model of MIDP 2.0 based on open standards.

MIDlets are usually available through MIDlet suites. A MIDlet suite consists of two files, a .jar and a .jad file. The Java ARchive (JAR) file contains compiled classes in a compressed and preverified format. The Java Application Descriptor (JAD) file is a plain text file containing information about a MIDlet suite. The MID will always download the JAD file first and inspect its contents. If the MIDlet suite is already installed, it will know if a newer version is available.

A MIDlet lifecycle have following steps...
startApp()
pauseApp()
destroyApp()

CLDC（Connected limited device configuration，有限连接设备配置）：这个配置定义了 Java应用程序接口以及支持手持设备的技术

MIDP（Mobile information devices profile，移动信息设备简表）：第一个实现的简表，补充了CLDC并且提供应用程序语义和控件、用户界面、持久存储器、网络和用于移动电话的计时器、双通道呼叫器和其他无线电设备。类似于J2SE中的Applet框架，它提供了基于javax、microedition、midlet包的MIDLet应用程序框架。

MIDLet：MIDP应用程序称为 MIDlet，为了创建一个MIDlet，就必须写一个扩展基本 MIDlet类的类。这有点类似常见的Applet或Servlet。MIDlets独有的东西是把多个MIDlet组成一个MIDlet套件的能力。这就允许MIDlet在一个单独的JVM环境中共享资源，比如一个数据库等等。

JADs and JARs

The basic components of any MIDlet suite you will deliver are the Java Application Descriptor (JAD) file and the Java Archive (JAR) file. Together, these two items are the MIDlet suite.

The JAD file, as the name implies, describes a MIDlet suite. The description includes the name of the MIDlet suite, the location and size of the JAR file, and the configuration and profile requirements. The file may also contain other attributes, defined by the Mobile Information Device Profile (MIDP), by the developer, or both. Attributes beginning with MIDlet- or MicroEdition- are reserved for use by the AMS. The JAD file syntax is similar to that of the java.util.Properties class found in the J2SE environment.

A MIDlet suite on a device is identified by the attribute tuple (MIDlet-Name, MIDlet-Version, MIDlet-Vendor). The JAR file will be installed from the location MIDlet-Jar-URL. The size of the download must agree with the MIDlet-Jar-Size value.

The JAR contains one or more MIDlets, specified in the JAD using the MIDlet- attribute.

jad是jar的描述文件。jad描述了jar的文件大小和位置。打开jad后，根据jad找到jar。
jad作用有很多。例如，我可以不下载jar,先下载jad(jad很小),了解一些jar的基本信息后，在决定是否下载jar.
jad里还可以存储一些key和value,在midlet运行的时候可能会用到。如果直接用jar运行，就得不到这些key和value.对于某些程序，就不能正常运行了。
JAVA游戏以及JAVA电子书都是由.JAD和.JAR两个文件组成的,其中.JAD属于说明文件,用来识别该JAVA程序是否匹配该型号手机以及手机读取时确定游戏容量(这就是为什么有时候有的游戏不能下载我们可以通过更改.JAD文件来使其可以下载的原因)而.JAR文件属于程序体文件,就是游戏本身了,所以呢,无论是下载JAVA电子书还是JAVA游戏,.JAD文件和.JAR文件都是必不可少的.

从JAR安装的时候，默认的配置文件是jar中的.mf文件。
如果从JAD安装，会优先使用JAD文件中的配置信息
另外，签名的信息的话，默认都是写在JAD文件中的。
如果没有JAD文件的话，那么你的Java程序就只能装在“应用程序”里面了。

JSR
JSR(Java 规范请求)是指向JCP(Java Community Process)提出新增一个标准化技术规范的正式请求。任何人都可以提交JSR(Java 规范请求)，以向Java平台增添新的API和服务。JSR已成为Java界的一个重要标准。

The JABWT specification defines an optional J2ME package for Bluetooth wireless technology. JABWT operates on top of the CLDC and is intended to extend the capabilities of profiles like the MIDP. JABWT use the GCF, defined in the CLDC specification, for Bluetooth communication.

Permission
The MIDP 2.0 specification defines an open-ended system of permissions. To make any type of network connection, a MIDlet must have an appropriate permission. For example, a MIDlet that uses HTTP to talk to a server must have permission to open an HTTP connection.

Each permission has a unique name;Permission names are not the same as class names, although they look similar.

The two most widely used techniques for session tracking are cookies and URL rewriting. A cookie is a piece of data that a Web server sends to the client. This piece of data is stored by the client and used the next time the client makes a request from that server. But if cookies are disabled by the browser, or more importantly, if the browser itself does not support them (as is the case with most wireless devices), then cookies are not of much use.

The other technique for session tracking is URL rewriting. This technique is ideal for clients that do not support cookies or have cookies disabled. In this technique, the session information is encoded into URLs that the server generates.

J2ME Web Services
JSR 172, the J2ME Web Services API (WSA) extends the Java 2 Platform, Micro Edition to support web services. The API's two optional packages standardize two areas of functionality that are crucial to clients of web services: remote service invocation and XML parsing.
To handle XML documents, the application can employ the JAXP subset API. To consume web services, it can use the JAX-RPC subset API, employing JSR 172 stubs and the runtime.

Debug
The exact same source code used with the WTK 2.5.2 builds and runs without a problem. But in SDK 3.0, it has the error message as [WARN] [rms ] javacall_file_open: _wopen failed.
Select Device "DefaultCldcPhone1"; other as Default; Click Finish

Database

2010-03-29T23:56:00.000-07:00

What are Views ?
A view allows you to assign the result of a query to a new private table. This table is given the name used in your VIEW query.
Although MySQL does not support views yet a sample SQL VIEW construct statement would look like:
CREATE VIEW TESTVIEW AS SELECT * FROM names;

What are Triggers ?
A trigger is a pre-programmed notification that performs a set of actions that may be commonly required. Triggers can be programmed to execute certain actions before or after an event occurs. Triggers are very useful as they they increase efficiency and accuracy in performing operations on databases and also are increase productivity by reducing the time for application development. Triggers however do carry a price in terms of processing overhead.

What are Procedures ?
Like triggers, Procedures or 'Stored' Procedures are productivity enhancers. Suppose you needed to perform an action using a programming interface to the database in say PERL and ASP. If a programmed action could be stored at the database level, it's obvious that it has to be written only once and cam be called by any programming language interacting with the database.
Procedures are executed using triggers.

Join table

embed sql

Choosing a Primary Key: Natural or Surrogate?
(http://www.agiledata.org/essays/keys.html )

Natural key. A key that is formed of attributes that already exist in the real world. For example, U.S. citizens are issued a Social Security Number (SSN)
Surrogate key. A key with no business meaning.
1. Avoid “smart” keys. A “smart” key is one that contains one or more subparts which provide meaning.
2. Consider assigning natural keys for simple “look up” tables. A “look up” table is one that is used to relate codes to detailed information.
3. Natural keys don’t always work for “look up” tables.
4. Your applications must still support “natural key searches”.
5. Don't naturalize surrogate keys.

Are You a Software Architect?

2010-03-29T20:45:00.000-07:00

Some of the key factors that are often used to differentiate software architecture from software design and development include an increase in scale, an increase in the level of abstraction and an increase in the significance of making the right design decisions. Software architecture is all about having a holistic view and seeing the bigger picture to understand how the software system works as a whole.
As the following diagram shows, the architecture definition part of the role can be broken down further into a number of different elements.

It's the same story with architecture delivery too, where the software architecture role can vary depending on the level of engagement across the elements that contribute to a successful software project.

P2P Systems

2010-03-24T23:08:00.001-07:00

Skype可以看作是一个叠加在互联网之上的网络。与以往MSN等IM工具最大的不同在于其除了用户登录，其余工作基本不依赖中央服务器。 Skype在穿透防火墙通讯时完全使用了Peer to Peer，而没用到中央服务器。每一个客户端都维护一个可以到达的主机列表（host cache，HC），包括其IP地址和端口号。

Skype的节点有两种：客户端（ordinary node）和超级节点（super node，SN）。
Skype采用了32kbps的语音编码以保证语音质量，其信令通过TCP传递，而语音数据则通过TCP和UDP进行传输，信令和语音数据使用不同的端口号。Skype能够向好友列表中的用户发送呼叫请求。为了保证信令传输的可靠性，信令始终是通过TCP进行的。如果双方都是在公众网中，有独立的公用IP，那么主叫用户和被叫用户通过challenge-response机制直接进行数据交换。如果有一方位于私有网络或者是防火墙之后，那么私有网络一方需要首先同公众网中的至少一个SN建立TCP链接，然后由SN进行数据转发。如果双方都位于私有网络中，那么双方的数据都需要SN进行转发。

Skype的好友列表没有保存在服务器上，而是保存在本地的注册表中，并进行了加密。这就使得用户如果更换了另外一台电脑之后需要重新构建好友列表

A Survey of Peer-to-Peer Content Distribution Technologies

2010-03-23T20:52:00.000-07:00

Although in their purest form peer-to-peer overlay networks are supposed to be totally decentralized, in practice this is not always true, and systems with various degrees of centralization are encountered.

Purely Decentralized Architectures.
All nodes in the network perform exactly the same tasks, acting both as servers and clients, and there is no central coordination of their activities.

Partially Centralized Architectures.
The basis is the same as with purely decentralized systems. Some of the nodes, however,assume a more important role, acting as local central indexes for files shared by local peers. The way in which these supernodes are assigned their role by the network varies between different systems. It is important, however, to note that these supernodes do not constitute single points of failure for a peer-to-peer network, since they are dynamically assigned and, if they fail, the network will automatically take action to replace them with others.

Hybrid Decentralized Architectures.
In these systems, there is a central server facilitating the interaction between peers by maintaining directories of metadata, describing the shared files stored by the peer nodes. Obviously, in these architectures, there is a single point of failure (the central server).

Network Structure
Unstructured.
The placement of content (files) is completely unrelated to the overlay topology. In an unstructured network, content typically needs to be located. Unstructured systems are generally more appropriate for accommodating highly-transient node populations.

Structured
In structured networks, the overlay topology is tightly controlled and files (or pointers to them) are placed at precisely specified locations. These systems essentially provide a mapping between content (e.g. file identifier) and location (e.g. node address), in the form of a distributed routing table, so that queries can be efficiently routed to the node with the desired content. A disadvantage of structured systems is that it is hard to maintain the structure required for efficiently routing messages in the face of a very transient node population.

The Art of Unix Programming

2010-03-23T01:13:00.000-07:00

Doug McIlroy, the inventor of Unix pipes and one of the founders of the Unix tradition, had this to say at
the time:

Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new features.
Expect the output of every program to become the input to another, as yet unknown, program. Don't clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don't insist on interactive input.
Design and build software, even operating systems, to be tried early, ideally within weeks. Don't hesitate to throw away the clumsy parts and rebuild them.
Use tools in preference to unskilled help to lighten a programming task, even if you have to detour to build the tools and expect to throw some of them out after you've finished using them.

Rob Pike, who became one of the great masters of C, offers a slightly different angle in Notes on C
Programming:

Rule 1. You can't tell where a program is going to spend its time. Bottlenecks occur in surprising places, so don't try to second guess and put in a speed hack until you've proven that's where the bottleneck is.
Rule 2. Measure. Don't tune for speed until you've measured, and even then don't unless one part of the code overwhelms the rest.
Rule 3. Fancy algorithms are slow when n is small, and n is usually small. Fancy algorithms have big constants. Until you know that n is frequently going to be big, don't get fancy. (Even if n does get big, use Rule 2 first.)
Rule 4. Fancy algorithms are buggier than simple ones, and they're much harder to implement. Use simple algorithms as well as simple data structures.
Rule 5. Data dominates. If you've chosen the right data structures and organized things well, the algorithms will almost always be self-evident. Data structures, not algorithms, are central to programming.

Unix philosophy:

Rule of Modularity: Write simple parts connected by clean interfaces.
Rule of Clarity: Clarity is better than cleverness.
Rule of Composition: Design programs to be connected to other programs.
Rule of Separation: Separate policy from mechanism; separate interfaces from engines.
Rule of Simplicity: Design for simplicity; add complexity only where you must.
Rule of Parsimony: Write a big program only when it is clear by demonstration that nothing else will do.
Rule of Transparency: Design for visibility to make inspection and debugging easier.
Rule of Robustness: Robustness is the child of transparency and simplicity.
Rule of Representation: Fold knowledge into data so program logic can be stupid and robust.
Rule of Least Surprise: In interface design, always do the least surprising thing.
Rule of Silence: When a program has nothing surprising to say, it should say nothing.
Rule of Repair: When you must fail, fail noisily and as soon as possible.
Rule of Economy: Programmer time is expensive; conserve it in preference to machine time.
Rule of Generation: Avoid hand-hacking; write programs to write programs when you can.
Rule of Optimization: Prototype before polishing. Get it working before you optimize it.
Rule of Diversity: Distrust all claims for “one true way”.
Rule of Extensibility: Design for the future, because it will be here sooner than you think.

Google AppEngine

2010-03-17T23:34:00.000-07:00

FAQ:

Can I use the Google Data API library on App Engine?

Yes, the Google Data Java client library can be used in App Engine, but you need to set a configuration option to avoid a runtime permissions error. Add the following to your appengine-web.xml file:

Limitations:

http://stackoverflow.com/questions/565963/hidden-limitations-of-google-app-engine

JUnit

2010-03-16T19:42:00.000-07:00

JUnit tests do not require human judgment to interpret, and it is easy to run many of them at the same time. When you need to test something, here is what you do:

Annotate a method with @org.junit.Test
When you want to check a value, import org.junit.Assert.* statically, call assertTrue() and pass a boolean that is true if the test succeeds

Tests need to run against the background of a known set of objects. This set of objects is called a test fixture.
When you have a common fixture, here is what you do:

Add a field for each part of the fixture
Annotate a method with @org.junit.Before and initialize the variables in that method
Annotate a method with @org.junit.After to release any permanent resources you allocated in setUp

Verifying that code completes normally is only part of programming. Making sure the code behaves as expected in exceptional situations is part of the craft of programming too. For example:

new ArrayList< object>().get(0);

This code should throw an IndexOutOfBoundsException. The @Test annotation has an optional parameter "expected" that takes as values subclasses of Throwable. If we wanted to verify that ArrayList throws the correct exception, we would write:

@Test(expected= IndexOutOfBoundsException.class) public void empty() { 
new ArrayList< object>().get(0); 
}

JDK 5

2010-03-16T19:20:00.000-07:00

Generics
Generics provides a way for you to communicate the type of a collection to the compiler, so that it can be checked.

Here is a simple example taken from the existing Collections tutorial:

// Removes 4-letter words from c. Elements must be strings
static void expurgate(Collection c) {
    for (Iterator i = c.iterator(); i.hasNext(); )
      if (((String) i.next()).length() == 4)
        i.remove();
}

Here is the same example modified to use generics:

// Removes the 4-letter words from c
static void expurgate(Collection c) {
    for (Iterator i = c.iterator(); i.hasNext(); )
      if (i.next().length() == 4)
        i.remove();
}

The For-Each Loop
Iterating over a collection is uglier than it needs to be. Consider the following method, which takes a collection of timer tasks and cancels them:

void cancelAll(Collection c) {
    for (Iterator i = c.iterator(); i.hasNext(); )
        i.next().cancel();
}

The iterator is just clutter. Furthermore, it is an opportunity for error. The iterator variable occurs three times in each loop: that is two chances to get it wrong. The for-each construct gets rid of the clutter and the opportunity for error. Here is how the example looks with the for-each construct:

void cancelAll(Collection c) {
    for (TimerTask t : c)
        t.cancel();
}

When you see the colon (:) read it as “in.” The loop above reads as “for each TimerTask t in c.”

Enums
The new enum declaration defines a full-fledged class (dubbed an enum type). It allows you to add arbitrary methods and

fields to an enum type, to implement arbitrary interfaces, and more.

Varargs
In past releases, a method that took an arbitrary number of values required you to create an array and put the values into the array prior to invoking the method.

public static String format(String pattern,
                                Object... arguments);

The three periods after the final parameter's type indicate that the final argument may be passed as an array or as a sequence of arguments. Varargs can be used only in the final argument position. Given the new varargs declaration for MessageFormat.format, the above invocation may be replaced by the following shorter and sweeter invocation:

String result = MessageFormat.format(
    "At {1,time} on {1,date}, there was {2} on planet "
    + "{0,number,integer}.",
    7, new Date(), "a disturbance in the Force");

There is a strong synergy between autoboxing and varargs, which is illustrated in the following program using reflection(The printf Method):

// Simple test framework
public class Test {
    public static void main(String[] args) {
        int passed = 0;
        int failed = 0;
        for (String className : args) {
            try {
                Class c = Class.forName(className);
                c.getMethod("test").invoke(c.newInstance());
                passed++;
            } catch (Exception ex) {
                System.out.printf("%s failed: %s%n", className, ex);
                failed++;
            }
        }
        System.out.printf("passed=%d; failed=%d%n", passed, failed);
    }
}

Static import
A static import declaration enables programmers to refer to imported static members as if they were declared in the class that uses them—the class name and a dot (.) are not required to use an imported static member.

import static java.lang.Math.*;
public function test()
{
    cos(1.0);
}

Annotations
It would be more convenient and less error-prone if the information in these side files were maintained as annotations in the program itself. Annotations do not directly affect program semantics, but they do affect the way programs are treated by tools and libraries, which can in turn affect the semantics of the running program. Annotations can be read from source files, class files, or reflectively at run time.

97 Things Every Software Architect Should Know

2010-03-05T01:07:00.000-08:00

Approach these events as conversations, not as confrontations.
If you assume the best about people and treat this situation as an opportunity to ask question, you definitely learn more, and are less likely to put people on the defensive.

If you start with a shared purpose, treat people "problems" as an opportunity to learn, and manage your own emotions, you'll not only become more effective, you'll also discover that you learn something every time.

The key to effective communication is clarity and leadership.
Being clear and concise in the way you communicate your ideas is vital to the success of any software project.
Having the developers on your side creates a collaborative environment whereby decisions you make as an architect are validated.

People need to appreciate that application architecture is the primary determinant of application performance and scalability rather than software brands or infrastructure "tuning".

Mobile operating system

2010-02-25T18:24:00.000-08:00

Android
The Android community primarily uses two SDKs. The most familiar one is the high-level Android SDK, which enables you to write application code in the Java™ language and commonly uses Eclipse for writing, testing, and debugging code. Another, less commonly known SDK is the Android kernel source, which is stored in what is known as a git repository.

Every Android application runs in its own process, with its own instance of the Dalvik virtual machine. Dalvik has been written so that a device can run multiple VMs efficiently. The Dalvik VM executes files in the Dalvik Executable (.dex) format which is optimized for minimal memory footprint. The VM is register-based, and runs classes compiled by a Java language compiler that have been transformed into the .dex format by the included "dx" tool.

A central feature of Android is that one application can make use of elements of other applications. For example, if your application needs to display a scrolling list of images and another application has developed a suitable scroller and made it available to others, you can call upon that scroller to do the work, rather than develop your own. Your application doesn't incorporate the code of the other application or link to it. Rather, it simply starts up that piece of the other application when the need arises.

For this to work, the system must be able to start an application process when any part of it is needed, and instantiate the Java objects for that part. Therefore, unlike applications on most other systems, Android applications don't have a single entry point for everything in the application (no main() function, for example). Rather, they have essential components that the system can instantiate and run as needed. There are four types of components:
Activities
An activity presents a visual user interface for one focused endeavor the user can undertake. Each activity is given a default window to draw in. Android has a number of ready-made views that you can use — including buttons, text fields, scroll bars, menu items, check boxes, and more.
Services
A service doesn't have a visual user interface, but rather runs in the background for an indefinite period of time.
Broadcast receivers
A broadcast receiver is a component that does nothing but receive and react to broadcast announcements. Many broadcasts originate in system code — for example, announcements that the timezone has changed, that the battery is low, that a picture has been taken, or that the user changed a language preference.
An application can have any number of broadcast receivers to respond to any announcements it considers important.
Content providers
A content provider makes a specific set of the application's data available to other applications. The data can be stored in the file system, in an SQLite database, or in any other manner that makes sense.

Before Android can start an application component, it must learn that the component exists. Therefore, applications declare their components in a manifest file that's bundled into the Android package, the .apk file that also holds the application's code, files, and resources.

To the user, it will seem as if the map viewer is part of the same application as your activity, even though it's defined in another application and runs in that application's process. Android maintains this user experience by keeping both activities in the same task. Simply put, a task is what the user experiences as an "application." It's a group of related activities, arranged in a stack. A task is a stack of activities, not a class or an element in the manifest file.

Intents are asynchronous messages which allow the application to send or receive data from and to other activities or services. Application register themselves to an intent via an IntentFilter. Intents are a powerful concept as they allow the creation of loosely coupled applications.
Intent filters are typically defined via the "AndroidManifest.xml" file. A component uses intent filter to define for which intents it can be responsible. If a component does not define intent filters it can only be called by explicit intents.

Android Installation

Download and unzip android SDK to a local folder.
Install ADT plug-in in Eclipse.
Config android SDK location in Eclipse.

J2ME

Mobile Tools for Java (MTJ)

LWUIT

A Theme allows us to set the style attributes for an entire class of components in a single place. This not only simplifies the task of setting attributes for all components of a particular type but also ensures that any newly added component will look just like all the others of the same type in the application. A theme thereby establishes a visual coherence through all the screens of an application.
A theme file is conceptually similar to CSS while its implementation is like that of a Java properties file. Essentially a theme is a list of key-value pairs with an attribute being a key and its value being the second part of the key-value pair An entry in the list may be Form.bgColor= 555555. This entry specifies that the background color of all forms in the application will be (hex) 555555 in the RGB format.

http://www.infoworld.com/d/developer-world/how-choose-mobile-development-platform-077

http://www.ibm.com/developerworks/opensource/library/os-android-devel/

Eclipse plugin http://developer.android.com/sdk/eclipse-adt.html

http://www.android123.com.cn/

http://apparchguide.codeplex.com/wikipage?title=Chapter%2019%20-%20Mobile%20Applications

http://www.theshulers.com/whitepapers/mobile_architecture/index.html

http://u.youku.com/user_show/id_UMTIyODk2MTgw.html

http://www.youtube.com/watch?v=_35jeLSIeU4

Install common softwares on Ubumtu

2010-02-25T01:35:00.000-08:00

1. JaveEE

2. Eclipse.

3. Code::Block
C++ IDE

Secure Internet Banking Authentication

2010-02-22T18:50:00.000-08:00

Offline credential-stealing attacks aim to fraudulently gather a user’s credentials either by invading an insufficiently protected client PC via malicious software (such as a virus or Trojan horse) or by tricking a user into voluntarily revealing his or her credentials via phishing.

Online channel-breaking attacks, as practiced by a malicious man in the middle, a commercially motivated market-scorer, (www.pcworld.com/news/article/0,aid,118757,00.asp), or a security-motivated content-inspector (www.microdasys.com) or Web washer (www.cyberguard.com), are even more sophisticated. Instead of trying to get the user’s credentials, the intruder unnoticeably
intercepts messages between the client PC and the banking server by masquerading as the server to the client and vice versa.

X.509
In cryptography, X.509 is an ITU-T standard for a public key infrastructure (PKI) for single sign-on (SSO) and Privilege Management Infrastructure (PMI).
RSA
In cryptography, RSA (which stands for Rivest, Shamir and Adleman who first publicly described it) is an algorithm for public-key cryptography[1]. It is the first algorithm known to be suitable for signing as well as encryption, and was one of the first great advances in public key cryptography.
SHA-1
The SHA hash functions are a set of cryptographic hash functions designed by the National Security Agency (NSA) and published by the NIST as a U.S. Federal Information Processing Standard. SHA stands for Secure Hash Algorithm.
MD5
In cryptography, MD5 (Message-Digest algorithm 5) is a widely used cryptographic hash function with a 128-bit hash value. As an Internet standard (RFC 1321), MD5 has been employed in a wide variety of security applications, and is also commonly used to check the integrity of files.
MAC
A message authentication code (often MAC) is a short piece of information used to authenticate a message.
A MAC algorithm, sometimes called a keyed (cryptographic) hash function, accepts as input a secret key and an arbitrary-length message to be authenticated, and outputs a MAC (sometimes known as a tag). The MAC value protects both a message's data integrity as well as its authenticity, by allowing verifiers (who also possess the secret key) to detect any changes to the message content.
MACs differ from digital signatures as MAC values are both generated and verified using the same secret key. This implies that the sender and receiver of a message must agree on the same key before initiating communications, as is the case with symmetric encryption.

SSO
Single sign-on (SSO) is a property of access control of multiple, related, but independent software systems. With this property a user logs in once and gains access to all systems without being prompted to log in again at each of them.

Data Mining: Concepts and Techniques

2010-02-22T01:54:00.000-08:00

A data warehouse is a repository of information collected from multiple sources, stored under a unified schema, and which usually resides at a single site. Data warehouses are constructed via a process of data cleaning, data transformation, data integration, data loading, and periodic data refreshing.

Automated theorem proving

2010-02-16T18:34:00.000-08:00

Automated theorem proving (ATP) or automated deduction, currently the most well-developed subfield of automated reasoning (AR), is the proving of mathematical theorems by a computer program.

In mathematical logic, a propositional calculus or logic (also called sentential calculus) is a formal system in which formulas of a formal language may be interpreted as representing propositions. A system of inference rules and axioms allows certain formulas to be derived, called theorems; which may be interpreted as true propositions. The series of formulas which is constructed within such a system is called a derivation and the last formula of the series is a theorem, whose derivation may be interpreted as a proof of the truth of the proposition represented by the theorem.

First-order logic is a formal logic used in mathematics, philosophy, linguistics, and computer science. It goes by many names, including: first-order predicate calculus, the lower predicate calculus, quantification theory, and predicate logic. First-order logic is distinguished from propositional logic by its use of quantifiers; each interpretation of first-order logic includes a domain of discourse over which the quantifiers range.

While propositional logic deals with simple declarative propositions, first-order logic additionally covers predicates and quantification.

Web Security

2010-02-11T19:29:00.000-08:00

Hypertext Transfer Protocol Secure (HTTPS) is a combination of the Hypertext Transfer Protocol with the SSL/TLS protocol to provide encryption and secure identification of the server. HTTPS connections are often used for payment transactions on the World Wide Web and for sensitive transactions in corporate information systems.

The main idea of HTTPS is to create a secure channel over an insecure network. This ensures reasonable protection from eavesdroppers and man-in-the-middle attacks, provided that adequate cipher suites are used and that the server certificate is verified and trusted.

The trust inherent in HTTPS is based on major certificate authorities which come pre-installed in browser software (this is equivalent to saying "I trust certificate authority (e.g. VeriSign/Microsoft/etc.) to tell me who I should trust"). Therefore an HTTPS connection to a website can be trusted.

Transport Layer Security (TLS) and its predecessor, Secure Sockets Layer (SSL), are cryptographic protocols that provide security for communications over networks such as the Internet. TLS and SSL encrypt the segments of network connections at the Transport Layer end-to-end.

The TLS protocol allows client/server applications to communicate across a network in a way designed to prevent eavesdropping and tampering. TLS provides endpoint authentication and communications confidentiality over the Internet using cryptography.

SSL协议提供的服务主要有：

1）认证用户和服务器，确保数据发送到正确的客户机和服务器；

2）加密数据以防止数据中途被窃取；

3）维护数据的完整性，确保数据在传输过程中不被改变。

一种常见的误解是“银行用户在线使用https:就能充分彻底保障他们的银行卡号不被偷窃。”实际上，与服务器的加密连接中能保护银行卡号的部分，只有用户到服务器之间的连接及服务器自身。并不能绝对确保服务器自己是安全的，这点甚至已被攻击者利用，常见例子是模仿银行域名的钓鱼攻击。少数罕见攻击在网站传输客户数据时发生，攻击者尝试窃听数据于传输中。

configuration of Apache Web server

2010-02-11T00:49:00.001-08:00

list all the files in a folder

add a .htaccess file in the folder



deny from all

Options Indexes
order deny,allow

Value chain

2010-02-03T19:28:00.000-08:00

A value chain is a chain of activities for a firm operating in a specific industry. Products pass through all activities of the chain in order and at each activity the product gains some value. The chain of activities gives the products more added value than the sum of added values of all activities. It is important not to mix the concept of the value chain with the costs occurring throughout the activities.

The costs and value drivers are identified for each value activity. The value chain framework quickly made its way to the forefront of management thought as a powerful analysis tool for strategic planning. Capturing the value generated along the chain is the new approach taken by many management strategists.

Value chain is a high-level model of how businesses receive raw materials as input, add value to the raw materials through various processes, and sell finished products to customers.

A knowledge value chain is a sequence of intellectual tasks by which knowledge workers build their employer's unique competitive advantage and/or social and environmental benefit. As an example, the components of a research and development project form a knowledge value chain.

GWT

2010-02-02T23:20:00.000-08:00

Google Web Toolkit is a comprehensive suite of programs developed by Google, which it provides free to the open source community (under the Apache 2.0 license) to implement Ajax.
Program code is written by the programmer. The programming language is Java. When the programmer is ready to "compile" the Java code, the google "compiler" program takes the code and converts it to a series of html and javascript files that can be displayed on most browsers.

JSON, short for JavaScript Object Notation, is a lightweight computer data interchange format. It is a text-based, human-readable format for representing simple data structures and associative arrays (called objects). The JSON format is often used for serialization and transmitting structured data over a network connection. Its main application is in Ajax web application programming, where it serves as an alternative to the XML format.
XML being a general-purpose markup language, they are syntactically more complex and bigger in file size than JSON, which, in contrast, is specifically designed for data interchange.

${\sum_{i=1}^nx_i}$

Computational trust

2010-01-31T22:57:00.000-08:00

The multi-agent system paradigm and the huge evolution of e-commerce are factors that contributed to the increase of interest on trust and reputation. In fact, Trust and reputation systems have been recognized as the key factors for a successful electronic commerce adoption. These systems are used by intelligent software agents as an incentive in decision-making, when deciding whether or not to honor contracts, and as a mechanism to search trustworthy exchange partners. In particular, reputation is used in electronic markets as a trust-enforcing mechanism or as a method to avoid cheaters and frauds.

Trust and reputation are considered subjective probabilities by which the individual A, expects the individual B to perform a given action on which its welfare depends.

Artificial Intelligence for Game

2010-01-19T00:48:00.000-08:00

The AI in most modern games addresses three basic needs: the ability to move characters; the ability to make decisions about where to move, and the ability to think tactically or strategically.
5 Decision Making
5.2 Decision trees
5.3 State machines
In a state machine each character occupies one state. Normally, actions or behaviors are associated with each state. So, as long as the character remains in that state, it will continue carrying out the same action.
States are connected together by transitions. Each transition leads from one state to another, the target state, and each has a set of associate conditions. If the game determines that the conditions of a transition are met, then the character change state to the transition's target state.

At each iteration(normally each frame), the state machine's update function is called. This checks to see if any transition from the current stat is triggered. The first transition that is triggered is scheduled to fire. The method then compiles a list of actions to perform from the currently active state. If a transition has been triggered, then the transition is fired. This separation of the triggering and the firing of transitions allows the transitions to also have their own actions.

Because state machines are often defined in a data file and read into the game at runtime, it is a common requirement to have a set of generic transitions.
Hierarchy state machine support transitions between levels of the hierarchy.
Decision trees are an efficient way of matching a series of conditions, and this has application in state machines for matching transitions. We can combine the two approaches by replacing transitions from a state with a decision tree. The leaves of the tree, rather than being actions as before, are transitions to new states.

5.4 Behavior trees
Behavior trees have a lot in common with Hierarchical State Machine but, instead of a state, the main building block of a behavior tree is a task. A task can be something as simple as looking up the value of a variable in the game state, or executing an animation.

Task are composed into sub-trees to represent more complex actions. In turn, these complex actions can again be composed into higher level behaviors. It is this composability that gives behavior trees their power.
Behavior trees really shine when coupled with a GUI to edit the tree. That way, designers, technical artists and level designers can potentially author complex AI behavior. The key difference in behavior tree is the use of a single common interface for all tasks.
Simple behavior tress will consist of three kinds of tasks: Conditions, Actions, Composites, and Decorators.
Condition test some property of the game.
Actions alter the state of the game.
Composite tasks includes:Selector and Sequence.
Decorator is a type of task that has one single child task and modifies its behavior in some way.
One simple Decorators makes a decision whether to allow their child behavior to run or not(They are sometimes called filters).
Decorator to guard the resource. (if the character's hands are moving through the reload animation, the can't be asked to wave.
A Selector will return immediately with a success status code when one of its children runs successfully.
A Sequence will return immediately with a failure status code when one of tis children fails. As long as its children are succeeding, it will keep going.
Behavior trees implement a very simple form of planning, sometimes called reactive planning. Selectors allow the character to try things, and fall back to other behaviors if they fail.

5.5 Fuzzy Logic
Fuzzy logic is relatively popular in the game industry. However, it has been largely discredited within the mainstream academic AI community.
It is always better to use probability to represent any kind of uncertainty. Part of reason why fuzzy logic ever became poplar was the perception that using probabilistic methods can be slow.

5.7 Goal-oriented behavior
Characters need to demonstrate their emotional and physical stat by choosing appropriate actions. We could simply run a decision tree that selects available actions based on the current emotional and physical parameters of the character. But it would lead to a very big decision tree.
A better approach would be to present the character with a suite of possible actions and have it choose the one that best meets its immediate needs.
A character may have one or more goals. Each goal has a level of importance (insistence) represented by a number. A goal with a high insistence will tend to influence the character's behavior more strongly.
The actions depend on the current state of the game. as the actions are added to the list of options they are rated against each motive the character has.
A simple approach would be to choose the most pressing goal (the one with the largest decrease in insistence) and find an action that either fulfills it completely or provides it with the largest decrease in insistence. It has two major weaknesses, however: it fails to take account of side effects that an action may have, and it doesn't incorporate any timing information.
The discontentment is calculated based on all the goal insistence values, where high insistence leaves the character more discontent. The aim of the character is to reduce its overall discontentment level. Discontentment is simply a score we are trying to minimize. It is known as an energy metric.

5.8 Rule-Based Systems
Rule based systems have a common structure consisting of two parts: a database containing knowledge available to the AI and a set of if-then rules. The rules trigger based on the contents of the database, and their effects can be more general than causing a state transition.
The "if" condition of the rule is matched against the database; a successful match triggers the rule. The condition, normally called a pattern. The database should only contain knowledge about the state of the game.
Many rule-based systems use a wild-card pattern matching, called unification, which can include wild cards.

5.9 Blackboard architecture
A blackboard architecture isn't a decision making tool in its own right. It is a mechanism for coordinating the actions of several decision makers. In games, we would like to be able to coordinate the decision making of several different techniques. Each technique may be able to make suggestions as to what to do next, but the final decision can only be make if they cooperate.
Rule based system is a kind of blackboard architecture which also have three elements:their database like blackboard containing data, each rule is like an expert - it can read from and write to the database, and there is an arbiter that controls which rule gets to fire.
Finite state machines are also a subset of the blackboard architecture (actually they are a subset of a rule-based system and, therefore, of a blackboard architecture).

5.10 Scripting
In the early and mid-1990s, most AI was hard-coded using custom written code to make decisions. As production became more complex, there arose a need to separate the content(behavior designs) from the engine.
Scripts can be treated as data files, and if the scripting language is simple enough level designers or technical artists can create the behaviors. An unexpected side effect of scripting language support is the ability for players to create their own character behavior and to extend the game.

5.11 Action execution
We can divide the kind of actions that result from AI decision into four flavors: state change actions, animations, movement, and AI requests.
State change actions are the simplest kind of action, simply changing some piece of the game state. it is often not directly visible to the player. For example, a character may change the firing mode of its weapon.
Animation are the most primitive kind of visual feedback. This might be a particle effect when a character casts a spell or a quick shuffle of the hands to indicate a weapon reload.
Movement algorithm can converts high level movement request into primitive actions.
In AI requests for complex characters, a high-level decision maker may be tasked with deciding which low level decision maker to use. For example, the AI controlling one team in a real-time strategy game may decide that it is time to build. A different AI may actually decide which building gets to be constructed.

Fuzzy Logic

2010-01-17T18:00:00.000-08:00

Fuzziness primarily describes uncertainty (partial true) and imprecision. The key idea of fuzziness comes from the multivalued logic: everything is a matter of degree.
Zadeh generalized the idea of a crisp set(bivalent set) by extending a valuation set{1,0}(definitely in/definitely out) to the interval of real values (degree of membership) between 0 and 1 denoted as [0,1].
Fuzzy sets represent/manipulate data and information processing non-statistical uncertainties.
The problem of constructing membership functions is not a problem of fuzzy set theory. It is a problem of knowledge acquisition, which is a subject of knowledge engineering.
Fuzzy sets tend to capture vagueness exclusively via membership functions that are mappings from a given universe of discourse X to a unit interval containing membership values.
Fuzzy logic provides an inference morphology that enables approximate human reasoning. In practice, fuzzy logic means computing with words.

A Fuzzy system is a collection of fuzzy rules that converts inputs to outputs.

Configure of Eclipse

2009-12-10T23:41:00.000-08:00

After install Eclipse and JavaEE, the classpath and installed Jre need config
1. Set window->preferences->Java->Installed JRES 更改jre home为C:\Sun\SDK\jdk\jre
2. Set window->preferences->Java->Build path->Classpath 添加更改jre home为C:/Sun/SDK/jdk/lib

Import a existing project:
File--> import --> Existing project

由于Eclipse本身是用Java语言编写的，而下载的压缩包中并不包含Java运行环境，因此需要用户自己另行安装JRE，并且要在操作系统的环境变量中指明JRE中bin的路径。如果上述设置不正确，Eclipse是无法正常运行的。

FAQ:

为什么我们不用把jre/bin目录到path中？
安装jre的时候安装程序自动帮你把jre的java.exe添加Windows/system32中。

"Could not find jar tool executable" When Packaging
EclipseME must find at least one full Java Development Kit within the Installed JRE's (a subcategory of the Java category). By default, Eclipse will recognize a JRE rather than a full JDK on Windows. To solve this problem, make sure to point the location of the installed JRE instance to the root directory of the JDK directory. For instance on Windows, that might be something like c:\j2sdk1.4.2.

Multimodal Learning Through Media: What the Research Says

2009-12-09T18:26:00.000-08:00

Recent technological advances confirm a dual coding system through which visuals and text/auditory input are processed in separate channels, presenting the potential for simultaneous augmentation of learning. The bottom
line is that students using well-designed combinations of visuals and text learn more than students who only use text.

The complexity of today’s global society and the accelerating rate of change require a citizenry that continuously learns, computes, thinks, creates, and innovates.

Experienced teachers recognize that the design of lessons must adapt to the expertise and prior knowledge of the learner, the complexity of the content, and interests of the learner. Experienced researchers recognize that the use of technology and multimedia, resources, and lessons can vary in the level of interactivity, modality, sequencing, pacing, guidance, prompts, and alignment to student interest, all of which influence the efficiency in learning.

With time a limited commodity in today’s society, people are tempted by technology to do more than one thing at a time (such as driving and talking on the phone, reading e-mails while participating in audio conferences, etc.). New scientific studies reveal the losses in efficiency in such multitasking.Researchers find that thinking processes happen serially, resulting in delays caused by switching from one task to another. The delays become more pronounced as the complexity of the task increases.

The working memory is dual coded with a buffer for storage of verbal/text elements, and a second buffer for visual/spatial elements.25

Within working memory, verbal/text memory and visual/spatial memory work together, without interference, to augment
understanding.

Learning is optimized when students can see where new concepts build on prior knowledge.

Expertise is developed through deep understanding. Students learn more when the concepts are personally meaningful to them. In order to deeply understand a topic, learners not only need to know relevant facts, theories, and applications, they must also make sense of the topic through organization of those ideas into a framework (schema) of understanding. The development of schema requires that students learn topics in ways that are relevant and meaningful to them.

Learning is optimized when students develop “metacognitive” strategies.Students who are metacognitive are students who approach problems by automatically trying to predict outcomes, explaining ideas to themselves, noting and learning from failures, and activating prior knowledge.

While the field is still evolving, researchers have shown that significant increases in learning can be accomplished through the informed use of visual and verbal multimodal learning.

The reality is that the most effective designs for learning adapt to include a variety of media, combinations of
modalities, levels of interactivity, learner characteristics, and pedagogy based on a complex set of circumstances.

In general, multimodal learning has been shown to be more effective than traditional, unimodal learning. Adding visuals to verbal (text and/or auditory) learning can result in significant gains in basic and higher-order learning.

Mobile Learning

2009-11-22T22:24:00.000-08:00

Mobile Learning Exchange

View more presentations from Dannno.

iPod touch for mobile learning

View more documents from Jonathan Nalder.

Semantic Web

2009-11-18T20:02:00.000-08:00

Web 3.0 The Semantic Web

The difference between Semantic Web and Web Services:
The mainstream XML standards for interoperation of web services specify only syntactic interoperability, not the semantic meaning of messages.

"If HTML and the Web made all the online documents look like one huge book, RDF, schema, and inference languages will make all the data in the world look like one huge database"
Tim Berners-Lee, Weaving the Web, 1999

RDF

RDF is a framework for describing Web resources.
RDF is data about data - or metadata. Often RDF files describe other RDF files.
An RDF pointer is a pointer (actually an URL) to information about things (like a knowledge database).
RDF identifies things using Web identifiers (URIs), and describes resources with properties and property values.The combination of a Resource, a Property, and a Property value forms a Statement (known as the subject, predicate and object of a Statement).
A container is a resource that contains things. The contained things are called members (not list of values)
RDF collections are used to describe groups that can contains ONLY the specified members.
The Dublin Core is a set of predefined properties for describing documents.

OWL

Ontology is about the exact description of things and their relationships.
OWL stands for Web Ontology Language. OWL is built on top of RDF. OWL is for processing information on the web.
OWL comes with a larger vocabulary and stronger syntax than RDF.
OWL has three sublanguages:

OWL Lite
OWL DL (includes OWL Lite)
OWL Full (includes OWL DL)

An OWL ontology consists of a set of axioms which place constraints on sets of individuals (called "classes") and the types of relationships permitted between them.

Semantic Web provides a common protocol for data and service to inter-operate.

Semantic Web provide a common manual way to define the logic rules and break the natural sentence to machine understandable concepts and relationships. It makes human to fit for machine.

Math

2009-11-12T01:15:00.000-08:00

Hash function

A hash function is any well-defined procedure or mathematical function which converts a large, possibly variable-sized amount of data into a small datum, usually a single integer that may serve as an index to an array.

In general, a hashing function may map several different keys to the same index. Therefore, each slot of a hash table is associated with (implicitly or explicitly) a set of records, rather than a single record. For this reason, each slot of a hash table is often called a bucket, and hash values are also called bucket indices.

An Introduction to MultiAgent Systems

2009-11-05T23:32:00.000-08:00

1. Introduction

In a classic distributed/concurrent system, all the computing elements are implicitly assumed to share a common goal(of making the overall system function correctly). In multiagent systems, it is assumed instead that agents are primarily concerned with their own welfare.
2. Intelligent Agents

An agent is a computer system that is situated in some environment, and that is capable of autonomous action in this environment in order to meet its design objectives.

In most domains of reasonable complexity, an agent will not have complete control over its environment. It will have a best partial control, in that it can influence it.
In practice, almost all realistic environments must be regarded as non-deterministic from an agent's perspective.
From agent's point of view, dynamic environments have at least two important properties. The first is that if an agent performs no external action between times t0 and t1, then it cannot assume that the environment at t1 will be the same as it was at time t0. The second property is that other processes in the environment can interfere with the actions it attempts to perform.
Functional systems f : I->O.
A functional system is one that simply takes some input, performs some computation over this input, and eventually produces some output.
Reactive systems
Reactive systems are harder to engineer than functional ones, because an agent engaging in a (conceptually) non-terminating relationship with its environment must continually make local decisions that have long-term consequences.

In an episodic environment, the performance of an agent is dependent on a number of discrete episodes, with no link between the performance of the agent in different episodes.
Intelligent agent has:

Reactivity. Intelligent agents are able to perceive their environment, and respond in a timely fashion to changes that occur in it in order to satisfy their design objectives.
Proactiveness. Intelligent agents are able to exhibit goal-directed behavious by taking the initiative in order to satisfy their design objectives.
Social ability. Intelligent agents are capable of interacting with other agents (and possibly humans) in order to satisfy their design objectives.

Achieving a good balance between goal-directed and reactive behavior is hard.

Environments are assumed to be history dependent. In other words, the next state of an environment is not solely determined by the action performed by the agent and the current state of the environment. The actions make earlier by the agent also play a part in determining the current state.

Certain types of agents decide what to do without reference to their history. They base their decision-making entirely on the present, with no reference at all to the past. We call such agents purely reactive, since they simply respond directly to their environment. Sometimes they are called tropistic agents)

More usually, we want to tell our agent what to do without telling it how to do it.

A utility is a numeric value representing how 'good' the state is: the higher the utility, the better. The task of the agent is then to bring about states that maximize utility.

It is difficult to specify a long-term view when assigning utilities to individual states. To get around this problem, we can specify a task as a function which assigns a utility not to individual states, but to runs themselves.

One of the disadvantages of utility-based approach is that it is very often difficult to derive an appropriate utility function. The second is that usually we find it more convenient to talk about tasks in terms of 'goals to be achieved' rather than utilities.

An achievement task is specified by a number of goal states; the agent is required to bring about one of these goal states. The environment and agent both begin in some state; the agent takes a turn by executing an action, and the environment responds with some state; the agent then takes another turn, and son on. The agent 'wins' if it can force the environment into one of the goal states.

Maintenance task environments: the agent is required to avoid some state of affairs.

3. Deductive Reasoning Agents

Traditional AI systems, known as symbolic AI, suggests that intelligent behavious can be generated in a system by giving that system a symbolic representation of its environment and its desired behaviour, and syntactically manipulating this representation.

In logic-based approaches to building agents, decision-making is viewed as deduction. The process of selecting an action reduces to a problem of proof. But logic-based approaches have many disadvantages. In particular, the inherent computational complexity of theorem proving makes it questionable whether agents as theorem provers can operate effectively in time-constrained environments.

4. Practical Reasoning Agents

Practice reasoning is a matter of weighing conflicting considerations for and against competing options, where the relevant considerations are provided by what the agent desires/values/cares about and what the agent believes.

Deciding what state of affairs to achieve is known as deliberation.

Deciding how to achieve these states of affairs is known as means-ends reasoning. It is better known in the AI community as planning.

A planner is a system that takes as input representations of the following.

A goal, intention or a task. This is something that the agent wants to achieve, or a state of affairs that the agent wants to maintain or avoid.
The current state of the environment - agent's beliefs.
The actions available to the agent.

As output, a planning algorithm generates a plan. This is a course of action - a 'recipe'.

The mechanism an agent uses to determine when and how to drop intentions is known as a commitment strategy.

The Belief-Desire-Intention (BDI) software model (usually referred to simply, but ambiguously, as BDI) is a software model developed for programming intelligent agents.A third activity, creating the plans in the first place (planning), is not within the scope of the model, and is left to the system designer and programmer.

Beliefs: Beliefs represent the informational state of the agent, in other words its beliefs about the world (including itself and other agents). Beliefs can also include inference rules, allowing forward chaining to lead to new beliefs.
Desires: Desires represent the motivational state of the agent. They represent objectives or situations that the agent would like to accomplish or bring about. Goals: A goal is a desire that has been adopted for active pursuit by the agent. Usage of the term goals adds the further restriction that the set of active desires must be consistent. For example, one should not have concurrent goals to go to a party and to stay at home - even though they could both be desirable.
Intentions: Intentions represent the deliberative state of the agent - what the agent has chosen to do. Intentions are desires to which the agent has to some extent committed. In implemented systems, this means the agent has begun executing a plan.
Events: These are triggers for reactive activity by the agent. An event may update beliefs, trigger plans or modify goals. Events may be generated externally and received by sensors or integrated systems. Additionally, events may be generated internally to trigger decoupled updates or plans of activity.

5 Reactive and Hybrid Agents

Subsumption architecture: no complex symbolic reasoning and many behavious can 'fire' simultaneously.

6 Multiagent Interactions

Utility function are just a way of representing an agent's preferences.

Dominant strategies.
We will say that a strategy si is dominant for player i if, no matter what strategy sj agent j choose, i will do at least as well playing si as it would doing anything else.
A strategy si for agent i is dominant if it is the best response to all of agent j's strategies.
Nash equilibria
The mutual form of an equilibrium is important because it locks the agents in to a pair of strategies. Neither agent has any incentive to deviate from a Nash equilibrium.
Mixed strategies and Nash's theorem
Sometimes, it can be useful to introduce randomness or uncertainty into our actions.
Every game in which every player has a finite set of possible strategies has a Nash equilibrium in mixed strategies.
Pareto efficiency
Pareto efficiency/optimality is not really a solution concept so much as a property of solution. It is a criterion that desirable solutions should satisfy.
We will say that an outcome is Pareto efficient if there is no other outcome that improves one player's utility without making somebody else worse off. Conversely, an outcome is said to be Pareto inefficient if there is another outcome that makes at least one player better off without making anybody else worse off.
While Pareto efficiency is an important property of outcomes, it is perhaps not very useful as a way of selecting outcomes.
Maximizing social welfare
Social welfare is an important property of outcomes, but is not generally a way of directly selecting outcomes.
Maximizing social welfare becomes relevant if all the agents within a system have the same owner.
Competitive and Zero-Sum Interactions
The preferences of the players are diametrically opposed to one another: one agent can only improve its lot at the expense of the other.(strictly competitive)
Zero-sum encounters are those in which, for any particular outcome, the utilities of the two agents sum to zero.
The Prisoner's Dilemma
The result seems to imply that cooperation can only arise as a result of irrational behavior, and that cooperative behavior can be exploited by those who behave rationally.
Rational cooperation is possible in the iterated prisoner's dilemma with an infinite number of rounds.
Even though a cooperative agent can suffer when playing against a defecting opponent, it can do well overall provided it it gets sufficient opportunity to interact with other cooperative agents.

7 Reaching Agreements

Mechanism design is the design of protocols for governing multiagent interaction, such that these protocols have certain desirable properties.

An auction takes place between an agent known as the auctioneer and a collection of agents known as the bidders. The goal of the auction is for the auctioneer to allocate the good to one of the bidders.

Negotiation: agent must reach agreements on the matters of mutual interest.

Argumentation

8 Communication

A certain class of natural language utterances - speech acts - had the characteristics of actions, in the sense that they change the state of the world in a way analogous to physical actions.

The Knowledge Query and Manipulation Language(KQML) is a message-based language for agent communication which define a common format for messages.

The Knowledge Interchange Format(KIF) is a language intended to form the content parts of KQML messages.

Ontologies enable agents to agree on the terminology that they use to describe a domain.

A DTD can be thought of as being analogous to the formal grammars used to define the syntax of programming languages.

9 Working Together

In parallel problem solving, the computational components are simply processors; a single node will be responsible for decomposing the overall problem into sub-components, allocating these to processors, and subsequently assembling the solution. The nodes are frequently assumed to be homogeneous in the sense that they do not have distinct expertise - they are simply processors to be exploited in solving the problem.

The Contract Net (CNET) protocol is a high-level protocol for achieving efficient cooperation through task sharing in networks of communicating problem solvers.

11 Applications

Agent for information retrieval and management

The most obvious difficulty from the point view of human users of the WWW is the 'information overload' problem. People get over-whelmed by the sheer amount of information available, making it hard for them to filter out the junk and irrelevancies and focus on what is important, and also to actively search for the right information.

In short, it is all too easy to become lost in cyberspace. When searching for a particular item of information, it is also easy for people to either miss or misunderstand things.

In multiagent information retrieval systems, each agent typically advertises its capabilities to some broker. Brokers come in several different types. They may be simply matchmakers or yellow page agent.

The goal of interface agents/expert assistants is to make computer programs that in certain circumstances could take the initiative, rather than wait for the user to spell out exactly what they wanted to do. This leads to the view of computer programs as cooperating with a user to achieve a task, rather than acting simply as servants.

Digital signature and encryption

2009-11-02T00:40:00.000-08:00

A digital signature or digital signature scheme is a mathematical scheme for demonstrating the authenticity of a digital message or document. A valid digital signature gives a recipient reason to believe that the message was created by a known sender(Authentication), and that it was not altered in transit(Integrity).

A digital signature scheme typically consists of three algorithms:

A key generation algorithm that selects a private key uniformly at random from a set of possible private keys. The algorithm outputs the private key and a corresponding public key.
A signing algorithm which, given a message and a private key, produces a signature.
A signature verifying algorithm which given a message, public key and a signature, either accepts or rejects.

Public-key cryptography

The two main branches of public key cryptography are:

Public key encryption — a message encrypted with a recipient's public key cannot be decrypted by anyone except a possessor of the matching private key -- presumably, this will be the owner of that key and the person associated with the public key used. This is used for confidentiality.
Digital signatures — a message signed with a sender's private key can be verified by anyone who has access to the sender's public key, thereby proving that the sender had access to the private key (and therefore is likely to be the person associated with the public key used), and the part of the message that has not been tampered with.

Artificial neural network

2009-10-26T22:52:00.000-07:00

There are three major learning paradigms, each corresponding to a particular abstract learning task. These are supervised learning, unsupervised learning and reinforcement learning. Usually any given type of network architecture can be employed in any of those tasks.

Supervised learning

Tasks that fall within the paradigm of supervised learning are pattern recognition (also known as classification) and regression (also known as function approximation).

Unsupervised learning

Tasks that fall within the paradigm of unsupervised learning are in general estimation problems; the applications include clustering, the estimation of statistical distributions, compression and filtering.

Reinforcement learning

Tasks that fall within the paradigm of reinforcement learning are control problems, games and other sequential decision making tasks.

Application areas include system identification and control (vehicle control, process control), quantum chemistry,[1] game-playing and decision making (backgammon, chess, racing), pattern recognition (radar systems, face identification, object recognition and more), sequence recognition (gesture, speech, handwritten text recognition), medical diagnosis, financial applications (automated trading systems), data mining (or knowledge discovery in databases, "KDD"), visualization and e-mail spam filtering.

Feedforward neural network

The feedforward neural network was the first and arguably simplest type of artificial neural network devised. In this network, the information moves in only one direction, forward, from the input nodes, through the hidden nodes (if any) and to the output nodes. There are no cycles or loops in the network.

Petri net

2009-10-21T01:12:00.000-07:00

A Petri net (also known as a place/transition net or P/T net) is one of several mathematical modeling languages for the description of discrete distributed systems.

A Petri net consists of places, transitions, and directed arcs. Arcs run between places and transitions, never between places or between transitions. The places from which an arc runs to a transition are called the input places of the transition; the places to which arcs run from a transition are called the output places of the transition.

Places may contain any non-negative number of tokens. A distribution of tokens over the places of a net is called a marking. A transition of a Petri net may fire whenever there is a token at the end of all input arcs; when it fires, it consumes these tokens, and places tokens at the end of all output arcs. A firing is atomic, i.e., a single non-interruptible step.

Reinforcement Learning

2009-10-21T01:10:00.000-07:00

Reinforcement learning is learning what to do--how to map situations to actions--so as to maximize a numerical reward signal.

The agent has to exploit what it already knows in order to obtain reward, but it also has to explore in order to make better action selections in the future. The agent must try a variety of actions and progressively favor those that appear to be best.

Learning theory

2009-10-06T18:28:00.000-07:00

There are three main categories or philosophical frameworks under which learning theories fall: behaviorism, cognitivism, and constructivism.

Behaviorism focuses only on the objectively observable aspects of learning.
Cognitive theories look beyond behavior to explain brain-based learning.
And constructivism views learning as a process in which the learner actively constructs or builds new ideas or concepts.

The effective learning is learner centered, knowledge centered, assessment centered, and community centered.

“new science of learning,” Bransford, Brown, and Cocking (1999)

Head first design patterns

2009-09-07T00:41:00.000-07:00

Chapter 1 (Strategy)

Instead of code reuse, with patterns you get experinece reuse.

Design Principle

Identify the aspects of your applicaion that vary and seperate them from what stays the same.

Program to an interface, not an implementation.

Favor composition over inheritance.

Program to an implementation would be

Dog d = new Dog();
d.bark();

Program to an interface would be

Animal a = new Dog();
a.makeSound();

Good OO designs are reuseable, extensiable and maitainable.

Most of patterns are principles address issues of change in software.

Most of patterns allow some part of a system to vary independly of all other part.

The Strategy pattern defines a family of algorithms, encapasulates each ones, and make them interchangable. Strategy let the algorithm vary independently from clients that use it.

Chapter 2(Observer)

Publisher(Subject) + Subscribers(Observers) = Observer Pattern

The Observer pattern defines a one to many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.

Design Principle

Strive for loosely coupled designs between objects that interact.

Java has build-in support for Observer, which are Observer interface and Observable class in the java.util package. Both JavaBean and Swing(addListener) also provide their own implementation of Observer Pattern.

Don't depend on a specific order of notification for your observers.

Chapter 3 (Decorator)

The Decorator Pattern attaches additional responsibilities to an object dynamically.Decorators provide a flexible alternative to subclassing for extending functionality.

Design Principle

Classes should be open for extension, but closed for modification.

Applying the Open-Closed Principle EVERYWHERE is wasteful, unnecessary, and can lead to complex, hard to understand code. Decorators have the same supertype as the objects they decorate. You can use one or more decorators to wrap an object.

Given that the decorator has the same supertype as the object it decorates, we can pass around a decorated object in place of the original (wrapped) object.

Java I/O package is largely based on Decorator. (FileInputStream, BufferedInputStream, LineNumberStream)

Dark side: Decorator Pattern sometimes adds a lot of small classes to a design and this occasionally results in a design that’s less than straightforward for others to understand.

You can usually insert decorators transparently and the client never has to know it’s dealing with a decorator.

But some code is dependent on specific types and when you start introducing decorators, boom! Bad things happen.

Composition and delegation can often be used to add new behaviors at runtime.

Decorator classes mirror the type of the components they decorate. (In fact, they are the same type as the components they decorate, either through inheritance or interface implementation.)

You can wrap a component with any number of decorators.

Decorators are typically transparent to the client of the component; that is, unless the client is relying on the component’s concrete type.

Decorators can result in many small objects in our design, and overuse can be complex.

Chapter 4 (Factory)

When you see "new", think "concrete". When you see new you are certainly instantiating a concrete class,

so that's definitly an implementation, not an interface.

A factory method handles object creation and encapsulate it in a subclass. This decouple the client code in the

superclass from the object creation code in the subclass.

The factory method pattern defines an interface for creating an object, but let subclass to decide thich

class to instanticate. Factory mechod lets the class defer instantiation to subclass.

Design Principle

Depend upon abstractions. Do not depend upon concrete classes.

The Abstract Factory Pattern provides an interface for creating families of related or depend objects

without specifying their concrete classes.

Abstract Factory allow a client to use an abstract interface to create a set of related products without knowing or caring about the concrete products that are actually produced.

Chapter 5 (Singleton Pattern)

The Singleton pattern ensures a class has only one intance, and provide a global single point of access to it.

Just keep in mind that synchronizing a method can decrease performance by a factor of 100.

Chapter 6 (Command Pattern)
The Command Pattern encapsulates a request as an object, thereby letting you parameterize other objects with different requests, queue or log requests, and support undoable operations.

A null object is useful when you don't have a meaningful object to return, and yet you want to remove the responsibility for handling null from the client. The null object will act as a surrogate and do nothing when its execute method is called.

Chapter 7 (Adapter and Facade Pattern)
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

Design Principle:
Principle of Least Knowledge - talk only to your immediate friends.
This principle prevents us from creating designs that have a large number of classes coupled together so that changes in one part of they system cascade to other classes.

Chapter 8 (Template Method Pattern)
The Template Method Pattern defines the skeleton of an algorithm in a method, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.

Design Principle:

The Hollywood Principle: Don't call us, we'll call you.

With the Hollywood Principle, we allow low-level components to hook themselves into a system, but the high-level components determine when they are needed, and how.

Chapter 9 (Iterator and Composite Pattern)
The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

Design Principle:

A class should have only one reason to change.

Cohesion is a term you will hear used as a measure of how closely a class or a module supports a single purpose or responsibility.

The Composite Pattern allows you to compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

Chapter 10 (State Pattern)
The state Pattern allows an object to alter its behavior when its internal state changes. The object will appear to change its class.

Chapter 11 (Proxy Pattern)
The Proxy Pattern provides a surrogate or placeholder for another object to control access to it.

Chapter 12 (Compound Pattern)
A compound pattern combines two or more patterns into a solution that solves a recurring or general problem.

Chapter 13 (Pattern in the real world)
A Pattern is a solution to a problem in a context.
Refactoring time is a Patterns time!
Take out what you don't really need. Don't be afraid to remove a Design Pattern from your design.
If you don't need it now, don't do it now.
The beginner uses patterns everywhere.
As learning progresses, the Intermediate mind states to see where patterns are needed and where they aren't.
The Zen mid is able to see patterns where they fit naturally.
When you use Design Patterns, there can also be a downside. Design Patterns often introduce additional classes and objects, and so they can increase the complexity of your designs. Design Pattern can also add more layers to your design, which adds not only complexity, but also inefficiency.

Chapter 14 (Leftover Patterns)
Bridge
Builder
Chain of Responsibility
Flyweight
Interpreter
Mediator
Memento
Prototype
Visitor

STL

2009-08-17T06:20:00.000-07:00

Container	Description
Sequences (Arrays / Linked Lists) - ordered collections
vector	a dynamic array, like C array (i.e., capable of random access) with the ability to resize itself automatically when inserting or erasing an object. Inserting and removing an element to/from back of the vector at the end takes amortized constant time. Inserting and erasing at the beginning or in the middle is linear in time. A specialization for type bool exists, which optimizes for space by storing bool values as bits.
list	a doubly-linked list; elements are not stored in contiguous memory. Opposite performance from a vector. Slow lookup and access (linear time), but once a position has been found, quick insertion and deletion (constant time).
deque (double ended queue)	a vector with insertion/erase at the beginning or end in amortized constant time, however lacking some guarantees on iterator validity after altering the deque.
Associative containers - unordered collections
set	a sorted set; inserting/erasing elements in a set does not invalidate iterators pointing in the set. Provides set operations union, intersection, difference, symmetric difference and test of inclusion. Type of data must implement comparison operator `<` or custom comparator function must be specified. Implemented using a self-balancing binary search tree.
multiset	same as a set, but allows duplicate elements.
map	a sorted associative array; allows mapping from one data item (a key) to another (a value). Type of key must implement comparison operator `<` or custom comparator function must be specified. Implemented using a self-balancing binary search tree.
multimap	same as a map, but allows duplicate keys.
hash_set hash_multiset hash_map hash_multimap	similar to a set, multiset, map, or multimap, respectively, but implemented using a hash table; keys are not sorted, but a hash function must exist for key type. These containers are not part of the C++ Standard Library, but are included in SGI's STL extensions, and are included in common libraries such as the GNU C++ Library in the `__gnu_cxx` namespace. These are scheduled to be added to the C++ standard as part of TR1, with the slightly different names of unordered_set, unordered_multiset, unordered_map and unordered_multimap.
Other types of containers
bitset	stores series of bits similar to a fixed-sized vector of bools. Implements bitwise operations and lacks iterators. Not a Sequence.
valarray	another C-like array like vector, but is designed for high speed numerics at the expense of some programming ease and general purpose use. It has many features that make it ideally suited for use with vector processors in traditional vector supercomputers and SIMD units in consumer-level scalar processors, and also ease vector mathematics programming even in scalar computers.

Iterators
The STL implements five different types of iterators. These are input iterators (which can only be used to read a sequence of values), output iterators (which can only be used to write a sequence of values),forward iterators (which can be read, written to, and move forward), bidirectional iterators (which are like forward iterators but can also move backwards) and random access iterators (which can move freely any number of steps in one operation).

Multi-thread programming

2009-08-17T02:33:00.000-07:00

Many modern operating systems directly support both time-sliced and multiprocessor threading with a process scheduler. The kernel of an operating system allows programmers to manipulate threads via the system call interface. Some implementations are called a kernel thread, whereas a lightweight process (LWP) is a specific type of kernel thread that shares the same state and information.

Operating systems schedule threads in one of two ways:

Preemptive multithreading is generally considered the superior approach, as it allows the operating system to determine when a context switch should occur. The disadvantage to preemptive multithreading is that the system may make a context switch at an inappropriate time, causing priority inversion or other negative effects which may be avoided by cooperative multithreading.
Cooperative multithreading, on the other hand, relies on the threads themselves to relinquish control once they are at a stopping point. This can create problems if a thread is waiting for a resource to become available.

A process is the "heaviest" unit of kernel scheduling. Processes own resources allocated by the operating system. Resources include memory, file handles, sockets, device handles, and windows.

A kernel thread is the "lightest" unit of kernel scheduling. At least one kernel thread exists within each process. If multiple kernel threads can exist within a process, then they share the same memory and file resources.

Threading APIs offer synchronization primitives such as mutexes to lock data structures against concurrent access.

POSIX Threads, or Pthreads, is a POSIX standard for threads. The standard defines an API for creating and manipulating threads. Pthreads are most commonly used on Unix-like POSIX systems such as FreeBSD, NetBSD, GNU/Linux, Mac OS X and Solaris, but Microsoft Windows implementations also exist.

POSIX (pronounced /ˈpɒzɪks/) or "Portable Operating System Interface [for Unix"] is the name of a family of related standards specified by the IEEE to define the application programming interface (API), along with shell and utilities interfaces for software compatible with variants of the Unix operating system, although the standard can apply to any operating system.

Cygwin – enables partial POSIX compliance for certain Microsoft Windows products.

A lock is a synchronization mechanism for enforcing limits on access to a resource in an environment where there are many threads of execution. Locks are one way of enforcing concurrency control policies.

The more coarse the lock, the higher the likelihood that the lock will stop an unrelated process from proceeding. Conversely, using a fine granularity (a larger number of locks, each protecting a fairly small amount of data) increases the overhead of the locks themselves but reduces lock contention. More locks also increase the risk of deadlock.

A semaphore is a protected variable or abstract data type which constitutes the classic method for restricting access to shared resources such as shared memory in a parallel programming environment. A counting semaphore is a counter for a set of available resources, rather than a locked/unlocked flag of a single resource. It was invented by Edsger Dijkstra. Semaphores are the classic solution to preventing race conditions in the dining philosophers problem, although they do not prevent resource deadlocks.

The value of a semaphore is the number of units of the resource which are free. (If there is only one resource, a "binary semaphore" with values 0 or 1 is used.) The P operation busy-waits (uses its turn to do nothing) or maybe sleeps (tells the system not to give it a turn) until a resource is available, whereupon it immediately claims one. V is the inverse; it simply makes a resource available again after the process has finished using it. Init is only used to initialize the semaphore before any requests are made.

Assume the resources are toilets in a public toilet. And the processes which want access to toilets are people either waiting in a queue for any toilet to be available or people who are already using the toilet. A person sitting outside the toilet keeps track of how many toilets are free at the moment and who should go in next.

The number of free toilets is the value of the semaphore indicating the number of free resources(toilets) available. When a process(person) wants access to a toilet the semaphore(incharge) will tell him whether he has to wait in the queue or whether he can use the toilet. If the toilet is free the person(process) gets the access and the number of free toilets is decreased by 1(same as P or down operation). It means number of free resources is less by 1. If the number of free toilets is 0 the person(process) has to wait in the queue till it becomes free(it means the process has to sleep till s>0). Once the person uses the toilet(process finishes it work with the resource) the next person can use it.It means the number of free toilets is increased by 1(this is same as calling V or Up operation). Now s has become greater than 0 and the person waiting(process sleeping) can have access to the toilet(resource).

Mutual exclusion (often abbreviated to mutex) algorithms are used in concurrent programming to avoid the simultaneous use of a common resource, such as a global variable, by pieces of computer code called critical sections.

A mutex is also a common name for a program object that negotiates mutual exclusion among threads, also called a lock.

An event is a type of synchronization mechanism that is used to indicate to waiting processes when a particular condition has become true.

An event is an abstract data type with a boolean state and the following operations:

* wait - when executed, causes the executing process to suspend until the event's state is set to true. If the state is already set to true has no effect.

* set - sets the event's state to true, release all waiting processes.

* clear - sets the event's state to false.

Message-oriented middleware (MOM)

2009-08-16T23:16:00.000-07:00

Message-oriented middleware (MOM) is infrastructure focused on sending and receiving messages that increases the interoperability, portability, and flexibility of an application by allowing the application to be distributed over heterogeneous platforms.

MOM comprises a category of inter-application communication software that generally relies on asynchronous message-passing, as opposed to a request-response metaphor.

Most message-oriented middleware depend on a message queue system, but there are some implementations that rely on broadcast or multicast messaging systems.

The primary advantage of a message-based communications protocol lies in its ability to store, route or transform messages in the process of delivery.

Storage, Routing, Transformation

The Java EE programming environment provides a standard API called JMS (Java Message Service), which is implemented by most MOM vendors and aims to hide the particular MOM API implementations; however, JMS does not define the format of the messages that are exchanged, so JMS systems are not interoperable.

Microsoft's MSMQ doesn't support JMS, although there are third-party products that can offer this.

The Advanced Message Queuing Protocol (AMQP) is an emerging standard that defines the protocol and formats used in the messaging server and client, so implementations are interoperable. AMQP is defined to provide flexible routing, including common messaging paradigms like point-to-point, fanout, publish/subscribe, and request-response. It also supports transaction management, queuing, distribution, security, management, clustering, federation and heterogeneous multi-platform support.

Project Management

2009-07-30T01:51:00.000-07:00

Two of those techniques were called Critical Path Management (CPM) and Program Evaluation and Review Techniques (PERT).

They were similar and you will now often find the technique refered to as: CPM/PERT.

Once you've identified the critical path, any delay on any part of the critical path will cause a delay in the whole project.

In MS Project, you use the Tracking Gantt diagram to show the critical path in red and you can see the PERT diagram by looking at the Network view.

Web Application Framework

2009-07-28T03:04:00.000-07:00

Django (pronunciation: /ˈdʒæŋgoː/, JANG-goh[1]) is an open source web application framework, written in Python, which follows the model-view-controller architectural pattern.

Enterprise Software

2009-07-14T01:23:00.000-07:00

Enterprise resource planning (ERP)

Enterprise resource planning (ERP) is a company-wide computer software system used to manage and coordinate all the resources, information, and functions of a business from shared data stores.[1]

An ERP system has a service-oriented architecture with modular hardware and software units and "services" that communicate on a local area network. The modular design allows a business to add or reconfigure modules (perhaps from different vendors) while preserving data integrity in one shared database that may be centralized or distributed.

The initials ERP originated as an extension of MRP (material requirements planning; later manufacturing resource planning) and CIM (Computer Integrated Manufacturing). ERP systems now attempt to cover all core functions of an enterprise, regardless of the organization's business or charter. These systems can now be found in non-manufacturing businesses, non-profit organizations and governments.

To be considered an ERP system, a software package must provide the function of at least two systems. For example, a software package that provides both payroll and accounting functions could technically be considered an ERP software package.

Ideally, ERP delivers a single database that contains all data for the software modules, which would include:

Manufacturing
Supply chain management
Financials
Project management
Human resources
Customer relationship management
Data warehouse
Access control
Customization

ERP systems typically handle the manufacturing, logistics, distribution, inventory, shipping, invoicing, and accounting for a company. ERP software can aid in the control of many business activities, including sales, marketing, delivery, billing, production, inventory management, quality management and human resource management.

Due to the complexities of most ERP systems and the negative consequences of a failed ERP implementation, most vendors have included "Best Practices" into their software. These "Best Practices" are what the Vendor deems as the most efficient way to carry out a particular business process in an Integrated Enterprise-Wide system.

ERP vendors have designed their systems around standard business processes, based upon best business practices. Different vendor(s) have different types of processes but they are all of a standard, modular nature. Firms that want to implement ERP systems are consequently forced to adapt their organizations to standardized processes as opposed to adapting the ERP package to the existing processes.

SAP ERP Enterprise Resource Planning (ERP)

SAP AG is the largest European software enterprise, with headquarters in Walldorf, Germany.

SAP is the world's largest business software company and the third-largest independent software provider in terms of revenues.

Service-oriented architecture moves the ERP (Enterprise Resource Planning) landscape toward software-based and web services-based business activities. This move increases adaptability, flexibility, openness and efficiency.

While its original products were typically used by Fortune 500 companies[citation needed], SAP is now also actively targeting small and medium sized enterprises (SME) with its SAP Business One and SAP Business All-in-One.

PeopleSoft

PeopleSoft, Inc. was a company that provided human resource management systems (HRMS), customer relationship management (CRM), manufacturing, financials, enterprise performance management, and student administration software solutions to large corporations, governments, and organizations. The Oracle Corporation acquired PeopleSoft,Inc..

PeopleSoft's product suite (also called PeopleSoft) was initially based on a client-server architecture. The entire software suite moved to a web-centric design called Pure Internet Architecture (PIA) with the release of PeopleSoft Version 8. The new format allowed all of a company's business functions to be accessed and run on a web browser.

The architecture is built around PeopleSoft’s proprietary PeopleTools technology. PeopleTools includes many different components a developer needs to create Web-based application using a SQL database; including a scripting language called PeopleCode, design tools to define various types of metadata, standard security structure, and batch processing tools. The metadata describes data for user interfaces, tables, messages, security, navigation, portals, and so forth. The benefit of creating their own development platform allowed PeopleSoft applications to run on top of many different operating systems and database platforms. Currently, it is not tied to any specific database platform.

As of 2008[3], Doris Wong of Oracle quoted the following statistics about PeopleSoft in use:

9 of top 10 commercial banks are PS customers
59% of top 100 of fortune 500 companies own PS
Retail - the 5 biggest use PS
6 of top 10 communications companies use PeopleSoft
60% of the top 15 insurance companies use PeopleSoft
70% of top 10 health care organizations use PeopleSoft
19 US States use PeopleSoft
50 of largest US Counties and Cities use PeopleSoft
7 of top 10 Research universities use PeopleSoft
8 of top 10 printing and publishing companies use PeopleSoft

The largest PeopleSoft system currently planned is for the United States Department of Defense, which has over 10 million people on payroll.

Ruby on Rails

2009-07-13T23:15:00.000-07:00

Ruby on Rails, often shortened to Rails or RoR, is an open source web application framework for the Ruby programming language. It is intended to be used with an Agile development methodology which is used by web developers for rapid development.Like many contemporary web frameworks, Rails uses the Model-View-Controller (MVC) architecture pattern to organize application programming.

Six Sigma

2009-07-13T04:19:00.000-07:00

Six Sigma is a business management strategy, initially implemented by Motorola, that today enjoys widespread application in many sectors of industry.

Six Sigma seeks to improve the quality of process outputs by identifying and removing the causes of defects (errors) and variation in manufacturing and business processes.

Sigma (the lower-case Greek letter σ) is used to represent the standard deviation (a measure of variation) of a statistical population. The term "six sigma process" comes from the notion that if one has six standard deviations between the process mean and the nearest specification limit, there will be practically no items that fail to meet specifications.

Agile software development

2009-07-13T04:10:00.000-07:00

Agile software development refers to a group of software development methodologies based on iterative development, where requirements and solutions evolve through collaboration between self-organizing cross-functional teams.

Agile methods break tasks into small increments with minimal planning, and don't directly involve long-term planning. Iterations are short time frames ("timeboxes") that typically last from one to four weeks. Each iteration is worked on by a team through a full software development cycle including planning, requirements analysis, design, coding, unit testing, and acceptance testing when a working product is demonstrated to stakeholders. This helps minimize overall risk, and lets the project adapt to changes quickly.

Test-driven development

Extreme Programming

DDoS attack

2009-07-09T23:20:00.000-07:00

A denial-of-service attack (DoS attack) or distributed denial-of-service attack (DDoS attack) is an attempt to make a computer resource unavailable to its intended users.

Wireless

2009-07-09T23:01:00.000-07:00

A nominal data rate of 100 Mbit/s while the client physically moves at high speeds relative to the station, and 1 Gbit/s while client and station are in relatively fixed positions as defined by the ITU-R,

A data rate of at least 100 Mbit/s between any two points in the world,

WiMax

WiMAX, meaning Worldwide Interoperability for Microwave Access, is a telecommunications technology that provides wireless transmission of data using a variety of transmission modes, from point-to-multipoint links to portable and fully mobile internet access. The technology provides up to 3 Mbit/s broadband speed without the need for cables. The technology is based on the IEEE 802.16 standard (also called Broadband Wireless Access).

WiMAX is a term coined to describe standard, interoperable implementations of IEEE 802.16 wireless networks, similar to the way the term Wi-Fi is used for interoperable implementations of the IEEE 802.11 Wireless LAN standard.

GPS
GPS的信号有两种C/A码，P码。
C/A码的误差是29.3m到2.93米。
P码的误差为2.93米到0.293米是C/A码的十分之一。但是P码只能美国军方使用，AS（Anti-Spoofing），是在P码上加上的干扰信号。