doc - Kenyth Zeng on Diigo

24 Dec 09

功能/非功能需求分哪几块，功能的优先级等等。实际工作中，这个阶段PD可能的产出物有Mind Manager的思维图，Excel的Feature List等。
功能/非功能需求分哪几块，功能的优先级等等。实际工作中，这个阶段PD可能的产出物有Mind Manager的思维图，Excel的Feature List等。
2 more annotations...
- 其内容涉及市场分析，销售策略，盈利预测等，通常是和老大们过的ppt
- PRD：Product Requirements Document，产品需求文档。进步一细化，这部分是PD写得最多的内容，也就是传统意义上的需求分析，我们这里主要指UC（use case）文档。主要内容有，功能使用的具体描述（每个UC一般有用例简述、行为者、前置条件、后置条件、UI描述、流程/子流程/分支流程，等几大块），Visio做的功能点业务流程，界面的说明，demo等。Demo方面，可能用dreamweaver、ps甚至画图板简单画一下，有时候也会有UI/UE支持，出高保真的demo，开发将来可以直接用的那种。

16 Dec 09

Python: module twitter

static.unto.net/...twitter.html - Preview

python twitter api doc opensource

15 Dec 09

Types and Property Classes - Google App Engine - Google Code

code.google.com/...typesandpropertyclasses.html - Preview

type db GAE doc

For unencoded byte strings longer than 500 bytes (also not indexed), use a Blob instance.
class Category(tag)

A category or "tag".
4 more annotations...
- class IM(protocol, address=None)
- Because ListProperty aggregate types do not use the Property classes, Property class features such as automatic values and validation are not applied automatically to members of the list value. If you want to validate a member value using a Property class, you can instantiate the class and call its validate() method on the value.
- The ReferenceProperty value can be used as if it were a model instance
- Deleting an entity does not delete entities referred to by a ReferenceProperty.

14 Dec 09

Datastore Python API Overview - Google App Engine - Google Code

code.google.com/...overview.html - Preview

db GAE key-value doc

The App Engine datastore is strongly consistent, but it's not a relational database. While the datastore interface has many of the same features of traditional databases, the datastore's unique characteristics imply a different way of designing and managing data to take advantage of the ability to scale automatically.
Each entity also has a key that uniquely identifies the entity. The simplest key has a kind and a unique numeric ID provided by the datastore. The ID can also be a string provided by the application.

An application can fetch an entity from the datastore by using its key, or by performing a query that matches the entity's properties.
6 more annotations...
- Unlike relational databases, the App Engine datastore does not require that all entities of a given kind have the same properties.
- Every datastore query uses an index, a table that contains the results for the query in the desired order.
- As the application makes changes to datastore entities, the datastore updates the indexes with the correct results. When the application executes a query, the datastore fetches the results directly from the corresponding index.
- You can make changes to multiple entities within a single transaction. To support this, App Engine needs to know in advance which entities will be updated together, so it knows to store them in a way that supports transactions. You must declare that an entity belongs to the same entity group as another entity when you create the entity. All entities fetched, created, updated or deleted in a transaction must be in the same entity group.
- Each entity has a path of parent-child relationships from a root entity to itself (the shortest path being no parent). This path is an essential part of the entity's complete key.
- The datastore uses optimistic concurrency to manage transactions.

12 Dec 09

Using the Datastore - Google App Engine - Google Code

code.google.com/...usingdatastore.html - Preview

GAE tutorial doc python db

Alternatively, you can call the gql(...) method on the Greeting class, and omit the SELECT * FROM Greeting from the query:
```
    greetings = Greeting.gql("ORDER BY date DESC LIMIT 10")
```
As with SQL, keywords (such as SELECT) are case insensitive. Names, however, are case sensitive.
2 more annotations...
- All GQL queries start with SELECT * FROM model (or are so implied by the model's gql(...) method) so as to resemble their SQL equivalents.
- dev_appserver.py --clear_datastore helloworld/

11 Dec 09

Python Application Configuration - Google App Engine - Google Code

code.google.com/...appconfig.html - Preview

GAE python config doc

All files in this directory are uploaded with the application as static files.
You can use this instead of static_dir to map to specific files in a directory structure without mapping the entire directory.
1 more annotations...
- This is necessary because the handler cannot determine which files in your application directory correspond with the given url and static_files patterns. Static files are uploaded and handled separately from application files.

Hello, World! - Google App Engine - Google Code

code.google.com/...helloworld.html - Preview

GAE python getting-started tutorial doc

When the server receives a request for your application, it runs the application with the request data in environment variables and on the standard input stream (for POST data). To respond, the application writes the response to the standard output stream, including HTTP headers and content.
ur source files and reload th

04 Dec 09

Using Google Public DNS

code.google.com/...using.html - Preview

Google dns doc

02 Nov 09

Apache Tomcat 4 - Class Loader HOW-TO

tomcat.apache.org/...class-loader-howto.html - Preview

tomcat doc classloader starred servlet-container servlet 4.1

Apache Tomcat 6.0 - Class Loader HOW-TO

tomcat.apache.org/...class-loader-howto.html - Preview

tomcat i18n doc classloader starred servlet-container servlet 6.0

Some JVMs may
implement this as more than one class loader, or it may not be visible
(as a class loader) at all.
the standard Tomcat 6 startup scripts
($CATALINA_HOME/bin/catalina.sh or
%CATALINA_HOME%\bin\catalina.bat) totally ignore the contents
of the CLASSPATH environment variable itself
6 more annotations...
- All unpacked classes and resources in
  $CATALINA_HOME/lib
- tomcat-i18n-**.jar - Optional JARs containing resource bundles
  for other languages. As default bundles are also included in each
  individual JAR, they can be safely removed if no internationalization
  of messages is needed.
- When a request to load a
  class from the web application's WebappX class loader is processed,
  this class loader will look in the local repositories first,
  instead of delegating before looking.
- All other class loaders in Tomcat 6 follow the usual delegation pattern.
- JDK 1.5 supports a mechanism called the "Endorsed Standards Override
  Mechanism" to allow replacement of APIs created outside of the JCP (i.e.
  DOM and SAX from W3C). It can also be used to update the XML parser
  implementation.
- Tomcat utilizes this mechanism by including the system property setting
  -Djava.endorsed.dirs=$JAVA_ENDORSED_DIRS in the
  command line that starts the container.

22 Sep 09

28.7. abc — Abstract Base Classes — Python v2.6.2 documentation

docs.python.org/abc.html - Preview

python abc doc

20 Sep 09

HowToLearnMoreScalability - memcached - Learn more about scalablity - Project Hosting on Google Code

code.google.com/...HowToLearnMoreScalability - Preview

scalability memcached doc reference Livejournal flickr scribd wikipedia starred toread

Django | How to use Django with FastCGI, SCGI, or AJP | Django Documentation

docs.djangoproject.com/...fastcgi - Preview

Django FastCGI apache httpd WSGI config doc howto

Like mod_python, FastCGI allows code to stay in memory, allowing requests to be
served with no startup time. Unlike mod_python (or mod_perl), a FastCGI
process doesn’t run inside the Web server process, but in a separate,
persistent process.
The traditional mod_* arrangements in Apache embed various scripting
languages (most notably PHP, Python and Perl) inside the process space of
your Web server.
6 more annotations...
- Before you can start using FastCGI with Django, you’ll need to install flup, a
  Python library for dealing with FastCGI.
- FastCGI operates on a client-server model, and in most cases you’ll be starting
  the FastCGI process on your own. Your Web server (be it Apache, lighttpd, or
  otherwise) only contacts your Django-FastCGI process when the server needs a
  dynamic page to be loaded.
- FastCGI server
- Django supports all the protocols that flup does, namely fastcgi, SCGI and
  AJP1.3 (the Apache JServ Protocol, version 1.3).
- ./manage.py runfcgi method=prefork socket=/home/user/mysite.sock pidfile=django.pid
- If you specify the pidfile option to runfcgi, you can kill the
  running FastCGI daemon like this:
  
  kill `cat $PIDFILE`
  
  ...where $PIDFILE is the pidfile you specified.

18 Sep 09

Django | Writing your first Django app, part 3 | Django Documentation

docs.djangoproject.com/...tutorial03 - Preview

python Django tutorial doc url-mapping mvc

creating a Python module, called a URLconf.
URLconfs are how Django associates
a given URL with given Python code.
17 more annotations...
- ROOT_URLCONF
- When it finds a match, Django calls the Python callback function, with an
  HttpRequest object as the first argument, any "captured"
  values from the regular expression as keyword arguments
- It finds the variable named urlpatterns
  and traverses the regular expressions in order
- The poll_id='23' part comes from (?P<poll_id>\d+). Using parenthesis
  around a pattern "captures" the text matched by that pattern and sends it as an
  argument to the view function
- All Django wants is that HttpResponse. Or an exception
- except Poll.DoesNotExist:
  raise Http404
- The get_object_or_404() function takes a Django model
  as its first argument and an arbitrary number of keyword arguments, which it
  passes to the module's get() function. It
  raises Http404 if the object doesn't exist.
- It finds it by looking for the
  variable handler404
- If DEBUG is set to True (in your settings module) then your
  404 view will never be used
- you still have one obligation: To create a 404.html
  template in the root of your template directory.
- If DEBUG is set to False (in your settings module) and if
  you didn't create a 404.html file, an Http500 is raised instead.
  So remember to create a 404.html.
- first Django does a dictionary lookup
  on the object poll. Failing that, it tries attribute lookup -- which works,
  in this case. If attribute lookup had failed, it would've tried calling the
  method question() on the poll object.
- Method-calling happens in the {% for %} loop
- decouple our poll-app URLs from
  our Django project configuration.
- include(), simply, references another URLconf.
- Whenever Django encounters
  include(), it chops off whatever part of the
  URL matched up to that point and sends the remaining string to the included
  URLconf for further processing.
- The idea behind include() and URLconf
  decoupling is to make it easy to plug-and-play URLs.

2. Lexical analysis — Python v2.6.2 documentation

docs.python.org/...lexical_analysis.html - Preview

syntax python doc programming language

The backslash (\) character is used to escape
characters that otherwise have a special meaning, such as newline, backslash
itself, or the quote character. String literals may optionally be prefixed with
a letter 'r' or 'R'; such strings are called raw strings and use
different rules for interpreting backslash escape sequences. A prefix of
'u' or 'U' makes the string a Unicode string. Unicode strings use the
Unicode character set as defined by the Unicode Consortium and ISO 10646. Some
additional escape sequences, described below, are available in Unicode strings.
The two prefix characters may be combined; in this case, 'u' must appear
before 'r'.
When an 'r' or 'R' prefix is present, a character following a backslash
is included in the string without change, and all backslashes are left in the
string.
2 more annotations...
- Specifically, a raw string cannot end in a
  single backslash (since the backslash would escape the following quote
  character).
- \uXXXX escape sequences are only recognized when there are an odd
  number of backslashes.

17 Sep 09

Django | Writing your first Django app, part 2 | Django Documentation

docs.djangoproject.com/...tutorial02 - Preview

python Django tutorial doc

create a file called
admin.py in your polls directory,
Normally,
the server auto-reloads code every time you modify a file, but the action of
creating a new file doesn't trigger the auto-reloading logic.
3 more annotations...
- The different model field types (DateTimeField,
  CharField) correspond to the appropriate HTML
  input widget. Each type of field knows how to display itself in the Django
  admin.
  Each DateTimeField gets free JavaScript
  shortcuts. Dates get a "Today" shortcut and calendar popup, and times get
  a "Now" shortcut and a convenient popup that lists commonly entered times.
- Note that any of Django's default admin templates can be overridden. To
  override a template, just do the same thing you did with base_site.html --
  copy it from the default directory into your custom directory, and make
  changes.
- by
  default, Django automatically looks for a templates/ subdirectory within
  each app package

Django | Writing your first Django app, part 1 | Django Documentation

docs.djangoproject.com/...tutorial01 - Preview

python Django tutorial doc

django-admin.py startproject mysite.
python manage.py runserver.
13 more annotations...
- By default, INSTALLED_APPS contains the following apps, all of which
  come with Django:
  
  django.contrib.auth -- An authentication system.
  django.contrib.contenttypes -- A framework for content types.
  django.contrib.sessions -- A session framework.
  django.contrib.sites -- A framework for managing multiple sites
  with one Django installation.
- python manage.py syncdb
  - pay attention to installing the MySQLdb module first. - on 2009-09-17
  Add Sticky Note
- Projects vs. apps
  
  What's the difference between a project and an app? An app is a Web
  application that does something -- e.g., a weblog system, a database of
  public records or a simple poll app. A project is a collection of
  configuration and apps for a particular Web site. A project can contain
  multiple apps. An app can be in multiple projects.
- You can use an optional first positional argument to a
  Field to designate a human-readable name.
- Django apps are "pluggable": You can use an app in multiple projects, and
  you can distribute apps,
- python manage.py sql polls
- The sql command doesn't actually run the SQL in your database -
  it just prints it to the screen
- syncdb can
  be called as often as you like, and it will only ever create the tables that
  don't exist.
- Putting mysite on sys.path.
- Setting the DJANGO_SETTINGS_MODULE environment variable, which gives
  Django the path to your settings.py file.
- set the DJANGO_SETTINGS_MODULE environment variable to
  mysite.settings.
- It's important to add __unicode__() methods to
  your models, not only for your own sanity when dealing with the interactive
  prompt, but also because objects' representations are used throughout Django's
  automatically-generated admin.
- We use
  __unicode__() here because Django models deal
  with Unicode by default. All data stored in your database is converted to
  Unicode when it's returned.

14 Sep 09

3. Data model — Python v2.6.2 documentation

docs.python.org/...datamodel.html - Preview

data-structure python type doc programming language

Every object has an identity, a type and a value.
Every object has an identity, a type and a value.
18 more annotations...
- Every object has an identity, a type and a value.
- An
  object’s mutability is determined by its type; for instance, numbers, strings
  and tuples are immutable, while dictionaries and lists are mutable.
- Objects are never explicitly destroyed; however, when they become unreachable
  they may be garbage-collected.
- note that catching
  an exception with a ‘try...except‘ statement may keep
  objects alive.
- ‘try...finally‘
- for immutable types, operations that
  compute new values may actually return a reference to any existing object with
  the same type and value
- This type has a single value.
- The Boolean type is a subtype of plain integers, and Boolean values
  behave like the values 0 and 1, respectively,
- When used as an expression, a slice is a
  sequence of the same type.
- There is no separate character type; a
  character is represented by a string of one item.
- The string data type is also
  used to represent arrays of bytes, e.g., to hold data read from a file.
- These represent unordered, finite sets of unique, immutable objects.
- The arguments of the call are passed
  to __new__() and, in the typical case, to __init__() to initialize
  the new instance.
- Class instances are callable only when the
  class has a __call__() method; x(arguments) is a shorthand for
  x.__call__(arguments).
- A class has a namespace implemented by a dictionary object.
  Class attribute references are translated to lookups in this dictionary, e.g.,
  C.x is translated to C.__dict__["x"]
- File objects are created by the
  open() built-in function, and also by os.popen(),
  os.fdopen(), and the makefile() method of socket objects
- The concept of (old-style) class is unrelated to the concept of type: if x is
  an instance of an old-style class, then x.__class__ designates the class of
  x, but type(x) is always <type 'instance'>.
- type(x) is typically the same as
  x.__class__

04 Sep 09

5. Validation, Data-binding, the BeanWrapper, and PropertyEditors

static.springsource.org/...ch05.html - Preview

validation springframework 3.0 doc

Specifically validation should not be
tied to the web tier, should be easy to localize and it should be
possible to plug in any validator available.

02 Sep 09

Maven - Introduction to Maven 2.0 Plugin Development

maven.apache.org/...introduction-to-plugins.html - Preview

maven plugin introduction doc

"Maven" is really just a core framework for a collection of Maven Plugins
it defaults to ${project.build.directory}
6 more annotations...
- A Mojo is really just a goal in Maven 2, and plug-ins consist of any number of goals (Mojos).
- Mojo specifies metadata about a goal: a goal name, which phase of the lifecycle it fits into, and the parameters it is expecting.
- MOJO is a play on POJO (Plain-old-Java-object), substituting "Maven" for "Plain".
- Starting with Maven 2.0, plugins implemented in different programming or scripting languages can coexist within the same build process.
- Also starting with Maven 2.0 is an effort to integrate multiproject builds directly into the core architecture.
- The ability to write Maven plugins entirely in Java

Kenyth Zeng's Library tagged doc → View Popular

互联网产品设计文档类型：有BRD、MRD、PRD和FSD - 产品经理(PD) - 业内网9点社区-互联网从业者互动家园 [每天9点来上班！]

Python: module twitter

Types and Property Classes - Google App Engine - Google Code

Datastore Python API Overview - Google App Engine - Google Code

Using the Datastore - Google App Engine - Google Code

Python Application Configuration - Google App Engine - Google Code

Hello, World! - Google App Engine - Google Code

Using Google Public DNS

Apache Tomcat 4 - Class Loader HOW-TO

Apache Tomcat 6.0 - Class Loader HOW-TO

28.7. abc — Abstract Base Classes — Python v2.6.2 documentation

HowToLearnMoreScalability - memcached - Learn more about scalablity - Project Hosting on Google Code

Django | How to use Django with FastCGI, SCGI, or AJP | Django Documentation

Django | Writing your first Django app, part 3 | Django Documentation

2. Lexical analysis — Python v2.6.2 documentation

Django | Writing your first Django app, part 2 | Django Documentation

Django | Writing your first Django app, part 1 | Django Documentation

3. Data model — Python v2.6.2 documentation

5. Validation, Data-binding, the BeanWrapper, and PropertyEditors

Maven - Introduction to Maven 2.0 Plugin Development

Selected Tags

Related Tags

Sponsored Links

Top Contributors

Groups interested in doc

Online Tools

Senior Mortgage Consultant NY

Accelerated Family Learning - Friends of Campaign4 Learning

eBooks Space for download FREE!!

Document Sharing

library doc