Python, JavaScript and all that Technology

2008-02-06T11:33:00.000-08:00

Dummies guide for using Slideshare Api using Ruby

2007-12-12T01:26:00.000-08:00

unix timestamp => TS = Time.now.to_i
get hash => HASH = Digest::SHA1.hexdigest(sharedsecret+TS)
Api Key => AKEY

AKEY and sharedsecret will be mailed to you once you apply for API

http://www.slideshare.net/developers/documentation

for ex:
http://www.slideshare.net/api/1/get_slideshow?api_key=AKEY&ts=TS&hash=HASH&username=UN&password=PWD&slideshow_id=Sid

unix timestamp in ruby

2007-12-12T00:42:00.000-08:00

Time.now.to_i

for more http://wiki.rubyonrails.org/rails/pages/PhpDateAndTimeFunctions

Adding classes/style to django form elements

2007-12-11T02:54:00.000-08:00

The 'attrs' argument to the Widget class used with each particular
Field (the Widget is what actually renders the HTML) accepts a
dictionary which will become HTML attribute names and values. For
example:

username = forms.CharField(widget=forms.TextInput(attrs={'class': 'myclass'}))

will become:

the old forms default of having class attributes for each
input type (e.g. class=vTextField for type=text)

populating select box from database ror

2007-12-09T22:53:00.000-08:00

controller code looks something like:

class testController < ApplicationController

def test
@categories= Category.find_all
end

end

use
<%= options_from_collection_for_select @categories, 'id', 'name' %>
to populate the select box

Django Forms

2007-12-08T03:05:00.000-08:00

Start with this basic Form subclass, which we’ll call ContactForm:

from django import newforms as forms

class ContactForm(forms.Form):
subject = forms.CharField(max_length=100)
message = forms.CharField()
sender = forms.EmailField()
cc_myself = forms.BooleanField(required=False)

A form is composed of Field objects.

Creating Form instances

A Form instance is either bound to a set of data, or unbound.

* If it’s bound to a set of data, it’s capable of validating that data and rendering the form as HTML with the data displayed in the HTML.
* If it’s unbound, it cannot do validation but it can still render the blank form as HTML.

To create an unbound Form instance, simply instantiate the class:

>>> f = ContactForm()

To bind data to a form, pass the data as a dictionary as the first parameter to your Form class constructor:

>>> data = {'subject': 'hello',
... 'message': 'Hi there',
... 'sender': 'foo@example.com',
... 'cc_myself': True}
>>> f = ContactForm(data)

In this dictionary, the keys are the field names, which correspond to the attributes in your Form class. The values are the data you’re trying to validate. These will usually be strings, but there’s no requirement that they be strings; the type of data you pass depends on the Field, as we’ll see in a moment.

If you need to distinguish between bound and unbound form instances at runtime, check the value of the form’s is_bound attribute:

>>> f = ContactForm()
>>> f.is_bound
False
>>> f = ContactForm({'subject': 'hello'})
>>> f.is_bound
True

Note that passing an empty dictionary creates a bound form with empty data:

>>> f = ContactForm({})
>>> f.is_bound
True

If you have a bound Form instance and want to change the data somehow, or if you want to bind an unbound Form instance to some data, create another Form instance. There is no way to change data in a Form instance. Once a Form instance has been created, you should consider its data immutable, whether it has data or not.

1) The primary task of a Form object is to validate data. With a bound Form instance, call the is_valid() method to run validation and return a boolean designating whether the data was valid:
2) Each Field in a Form class is responsible not only for validating data, but also for “cleaning” it — normalizing it to a consistent format.

f.errors
In this dictionary, the keys are the field names, and the values are lists of Unicode strings representing the error messages. The error messages are stored in lists because a field can have multiple error messages.

f.cleaned_data
If your data does not validate, your Form instance will not have a cleaned_data attribute:

cleaned_data will always only contain a key for fields defined in the Form, even if you pass extra data when you define the Form. In this example, we pass a bunch of extra fields to the ContactForm constructor, but cleaned_data contains only the form’s fields:

print f

You can access errors without having to call is_valid() first. The form’s data will be validated the first time either you call is_valid() or access errors.

The validation routines will only get called once, regardless of how many times you access errors or call is_valid()

Each field type has a default HTML representation. CharField and EmailField are represented by an . BooleanField is represented by an . Note these are merely sensible defaults; you can specify which HTML to use for a given field by using widgets

Use the auto_id argument to the Form constructor to control the label and id behavior. This argument must be True, False or a string.
If auto_id is False, then the form output will not include tags nor id attributes: f = ContactForm(auto_id=False)

To reorder the HTML output, just change the order in which those fields are listed in the class.

By default, forms use django.newforms.util.ErrorList to format validation errors. If you’d like to use an alternate class for displaying errors, you can pass that in at construction time:

>>> from django.newforms.util import ErrorList
>>> class DivErrorList(ErrorList):
... def __unicode__(self):
... return self.as_divs()
... def as_divs(self):
... if not self: return u''
... return u'

' % ''.join([u'

' % e for e in self])
>>> f = ContactForm(data, auto_id=False, error_class=DivErrorList)

>>> str(f['subject'])
''
>>> unicode(f['subject'])
u''

For a field’s list of errors, access the field’s errors attribute. This is a list-like object that is displayed as an HTML

when printed:

Subclassing forms

If you have multiple Form classes that share fields, you can use subclassing to remove redundancy.

When you subclass a custom Form class, the resulting subclass will include all fields of the parent class(es), followed by the fields you define in the subclass.

In this example, ContactFormWithPriority contains all the fields from ContactForm, plus an additional field, priority. The ContactForm fields are ordered first:

>>> class ContactFormWithPriority(ContactForm):
... priority = forms.CharField()
>>> f = ContactFormWithPriority(auto_id=False)

It’s possible to subclass multiple forms, treating forms as “mix-ins.” In this example, BeatleForm subclasses both PersonForm and InstrumentForm (in that order), and its field list includes the fields from the parent classes:

>>> class PersonForm(Form):
... first_name = CharField()
... last_name = CharField()
>>> class InstrumentForm(Form):
... instrument = CharField()
>>> class BeatleForm(PersonForm, InstrumentForm):
... haircut_type = CharField()
>>> b = BeatleForm(auto_id=False)

label

The label argument lets you specify the “human-friendly” label for this field. This is used when the Field is displayed in a Form.

As explained in “Outputting forms as HTML” above, the default label for a Field is generated from the field name by converting all underscores to spaces and upper-casing the first letter. Specify label if that default behavior doesn’t result in an adequate label.

The error_messages argument lets you override the default messages that the field will raise. Pass in a dictionary with keys matching the error messages you want to override.
name = forms.CharField(error_messages={'required': 'Please enter your name'})

In general, any cleaning method can raise ValidationError if there is a problem with the data it is processing, passing the relevant error message to the ValidationError constructor. If no ValidationError is raised, the method should return the cleaned (normalised) data as a Python object.

A widget is Django’s representation of a HTML input element. The widget handles the rendering of the HTML, and the extraction of data from a GET/POST dictionary that corresponds to the widget.

Django provides a representation of all the basic HTML widgets, plus some commonly used groups of widgets:
Whenever you specify a field on a form, Django will use a default widget that is appropriate to the type of data that is to be displayed.

However, if you want to use a different widget for a field, you can - just use the ‘widget’ argument on the field definition. For example:

class CommentForm(forms.Form):
name = forms.CharField()
url = forms.URLField()
comment = forms.CharField(widget=forms.Textarea)

This would specify a form with a comment that uses a larger Textarea widget, rather than the default TextInput widget

If you want to make one widget look different to another, you need to specify additional attributes for each widget. When you specify a widget, you can provide a list of attributes that will be added to the rendered HTML for the widget.

class CommentForm(forms.Form):
name = forms.CharField(
widget=forms.TextInput(attrs={'class':'special'}))
url = forms.URLField()
comment = forms.CharField(
widget=forms.TextInput(attrs={'size':'40'}))

Django will then include the extra attributes in the rendered output:

Custom Widgets

When you start to write a lot of forms, you will probably find that you will reuse certain sets of widget attributes over and over again. Rather than repeat these attribute definitions every time you need them, Django allows you to capture those definitions as a custom widget.

For example, if you find that you are including a lot of comment fields on forms, you could capture the idea of a TextInput with a specific size attribute as a custom extension to the TextInput widget:

class CommentWidget(forms.TextInput):
def __init__(self, *args, **kwargs):
kwargs.setdefault('attrs',{}).update({'size': '40'})
super(CommentWidget, self).__init__(*args, **kwargs)

Then you can use this widget in your forms:

class CommentForm(forms.Form):
name = forms.CharField()
url = forms.URLField()
comment = forms.CharField(widget=CommentWidget)

You can even customize your custom widget, in the same way as you would any other widget. Adding a once-off class to your CommentWidget is as simple as adding an attribute definition:

class CommentForm(forms.Form):
name = forms.CharField(max_length=20)
url = forms.URLField()
comment = forms.CharField(
widget=CommentWidget(attrs={'class': 'special'}))

Django also makes it easy to specify a custom field type that uses your custom widget. For example, you could define a customized field type for comments by defining:

class CommentInput(forms.CharField):
widget = CommentWidget

You can then use this field whenever you have a form that requires a comment:

class CommentForm(forms.Form):
name = forms.CharField()
url = forms.URLField()
comment = CommentInput()

initial

The initial argument lets you specify the initial value to use when rendering this Field in an unbound Form.

The use-case for this is when you want to display an “empty” form in which a field is initialized to a particular value.

The widget argument lets you specify a Widget class to use when rendering this Field.

render_to_response()

2007-11-24T23:30:00.000-08:00

render_to_response()

Because it’s such a common idiom to load a template, fill a Context and return an HttpResponse object with the result of the
rendered template, Django provides a shortcut that lets you do those things in one line of code. This shortcut is a function
called render_to_response(), which lives in the module django.shortcuts. Most of the time, you’ll be using render_to_response() rather than loading templates and creating Context and HttpResponse objects manually.

Here’s the ongoing current_datetime example rewritten to use render_to_response():

from django.shortcuts import render_to_response
import datetime
def current_datetime(request):
now = datetime.datetime.now()
return render_to_response('current_datetime.html', {'current_date': now})

What a difference! Let’s step through the code changes:
l We no longer have to import get_template, Template, Context or HttpResponse. Instead, we
import django.shortcuts.render_to_response. The import datetime remains.
l Within the current_datetime function, we still calculate now, but the template loading, context creation, template rendering
and HttpResponse creation is all taken care of by the render_to_response() call. Because render_to_response() returns
an HttpResponse object, we can simply return that value in the view.
The first argument to render_to_response() should be the name of the template to use, relative to your template directory. The
second argument, if given, should be a dictionary to use in creating a Context for that template. If you don’t provide a second
argument, render_to_response() will use an empty dictionary

Django Stuff - 1

2007-11-23T18:32:00.000-08:00

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.

Each model is a Python class that subclasses django.db.models.Model.
Each attribute of the model represents a database field.
Model metadata (non-field information) goes in an inner class named Meta.
Metadata used for Django’s admin site goes into an inner class named Admin

Executing Custon SQL
def my_custom_sql(self):
from django.db import connection
cursor = connection.cursor()
cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz])
row = cursor.fetchone()
return row

How Django processes a request

When a user requests a page from your Django-powered site, this is the algorithm the system follows to determine which Python code to execute:
Django looks at the ROOT_URLCONF setting in your settings file. This should be a string representing the full Python import path to your URLconf. For example: "mydjangoapps.urls".
Django loads that Python module and looks for the variable urlpatterns. This should be a Python list, in the format returned by the function django.conf.urls.defaults.patterns().
Django runs through each URL pattern, in order, and stops at the first one that matches the requested URL.
Once one of the regexes matches, Django imports and calls the given view, which is a simple Python function. The view gets passed a request object as its first argument and any values captured in the regex as remaining arguments.

More Commands @ FreeBSD

2007-04-24T23:02:00.000-07:00

Clearing the Terminal:

Clear

Adding a User:

adduser  [-u uid [-o]] [-g group] [-G group,...]
[-d home] [-s shell] [-c comment] [-m [-k template]]
[-f inactive] [-e expire mm/dd/yy] [-p passwd] [-n] [-r] name
adduser  -D [-g group] [-b base] [-s shell] [-f inactive] [-e expire mm/dd/yy]

To see what groups anyone else belongs to:

Add their login name to the end of the groups command like so:
groups genisis

Add a group:

pw group add group1

To add users user1 and user2 to the group( group1):

pw groupmod group1 -M user1,user2

Commands @ FreeBSD

2007-04-19T02:16:00.000-07:00

Delete all contents of a directory

rm -f *

Download a file from a URL

wget URL

Delete a directory

rm -r dirname

Delete a file

rm -f filename

List Processes

ps ax

Killing a process

Kill -9 PID

Finding a file

find (where to find) -name FileName

Counting number of lines in a file @ python

2007-04-10T23:04:00.000-07:00

f = open(filename)
lines = f.readlines()
f.close()

print "%s has %d lines." % (filename, len(lines))

copying data from one table to another @ mysql

2007-03-28T22:41:00.000-07:00

insert into tbl (field1,field2) select field1,field2 from users

Loops @ Ruby

2007-03-27T00:32:00.000-07:00

n.times {|i| puts i}

Well, the method Integer#times iterate self times (n in this) and for each iteration calls the block, gives it the current value।

something do |line|
#process something and line here
end

something' is a method and this method call the block with
some value.

For example if you want to read a file, you write

IO.foreach('file') do |line|
# do something with line
end

the method IO::foreach open the file given in argument, read each line and
call the block, given it the current line. At the end, IO::foreach close
the file

n.times {|i| puts i}

or

n.times do |i|
puts i
end

a=["hello","to","you"]
a.each {|i| puts i}

(1..10)each{|i| puts i}

or

for i in (1..10)
puts i
end

File Handling @ Python

2007-03-26T09:43:00.000-07:00

A file object maintains state about the file it has open. The tell method of a file object tells you your current position in the open file. Since you haven't done anything with this file yet, the current position is 0, which is the beginning of the file.
The seek method of a file object moves to another position in the open file. The second parameter specifies what the first one means; 0 means move to an absolute position (counting from the start of the file), 1 means move to a relative position (counting from the current position), and 2 means move to a position relative to the end of the file. Since the MP3 tags you're looking for are stored at the end of the file, you use 2 and tell the file object to move to a position 128 bytes from the end of the file.
The tell method confirms that the current file position has moved.
The read method reads a specified number of bytes from the open file and returns a string with the data that was read। The optional parameter specifies the maximum number of bytes to read. If no parameter is specified, read will read until the end of the file. (You could have simply said read() here, since you know exactly where you are in the file and you are, in fact, reading the last 128 bytes.) The read data is assigned to the tagData variable, and the current position is updated based on how many bytes were read.

import os
def filesnsubfiles(root):
file = os.listdir(root)
for i in file:
if os.path.isdir(root + "\\" + i):
filesnsubfiles(root + "\\" + i)
else:
print (root + "\\" + i)

Ubiquitous Ubuntu

2007-03-16T22:57:00.000-07:00

gconf-editor

installing make command
http://www.linuxforums.org/forum/ubuntu-help/66650-installing-make-command-offline.html

ActionScript

2007-03-12T22:16:00.000-07:00

Some of the differences between ActionScript and JavaScript are as follows:

• ActionScript does not support browser-specific objects such as Document, Window,
and Anchor.
• ActionScript does not completely support all the JavaScript built-in objects.
• ActionScript does not support some JavaScript syntax constructs, such as statement labels.
• In ActionScript, the eval() action can perform only variable references

An introduction to important ActionScript terms.

Actions are statements that instruct a SWF file to do something while it is playing. For example,
gotoAndStop() sends the playhead to a specific frame or label. In this manual, the terms action
and statement are interchangeable.
Boolean is a true or false value.
Classes are data types that you can create to define a new type of object. To define a class,
you use the class keyword in an external script file (not in a script you are writing in the
Actions panel).

Constants are elements that don’t change. For example, the constant Key.TAB always has the
same meaning: it indicates the Tab key on a keyboard. Constants are useful for comparing values.
Constructors are functions that you use to define the properties and methods of a class.
By definition, constructors are functions within a class definition that have the same name
as the class. For example, the following code defines a Circle class and implements a
constructor function:
// file Circle.as
class Circle {
private var radius:Number
private var circumference:Number
// constructor
function Circle(radius:Number) {
circumference = 2 * Math.PI * radius;
}
}
The term constructor is also used when you create (instantiate) an object based on a particular
class. The following statements are constructors for the built-in Array class and the custom
Circle class:
my_array:Array = new Array();
my_circle:Circle = new Circle();

Data types describe the kind of information a variable or ActionScript element can hold. The
ActionScript data types are String, Number, Boolean, Object, MovieClip, Function, null, and
undefined.

Events are actions that occur while a SWF file is playing. For example, different events are
generated when a movie clip loads, the playhead enters a frame, the user clicks a button or movie
clip, or the user types on the keyboard

Event handlers are special actions that manage events such as mouseDown or load. There are two
kinds of ActionScript event handlers: event handler methods and event listeners. (There are also
two event handlers, on() and onClipEvent(), that you can assign directly to buttons and movie
clips.) In the Actions toolbox, each ActionScript object that has event handler methods or event
listeners has a subcategory called Events or Listeners. Some commands can be used both as event
handlers and as event listeners and are included in both subcategories

Identifiers are names used to indicate a variable, property, object, function, or method. The first
character must be a letter, underscore (_), or dollar sign ($). Each subsequent character must be a
letter, number, underscore, or dollar sign. For example, firstName is the name of a variable.

Instances are objects that belong to a certain class. Each instance of a class contains all the
properties and methods of that class. For example, all movie clips are instances of the MovieClip
class, so you can use any of the methods or properties of the MovieClip class with any movie
clip instance

Instance names are unique names that let you target movie clip and button instances in scripts.
You use the Property inspector to assign instance names to instances on the Stage. For example, a
master symbol in the library could be called counter and the two instances of that symbol in
the SWF file could have the instance names scorePlayer1_mc and scorePlayer2_mc. The
following code sets a variable called score inside each movie clip instance by using
instance names:
_root.scorePlayer1_mc.score += 1;
_root.scorePlayer2_mc.score -= 1;
You can use special suffixes when naming instances

Methods
are functions associated with a class. For example, getBytesLoaded() is a built-in
method associated with the MovieClip class. You can also create functions that act as methods,
either for objects based on built-in classes or for objects based on classes that you create

Objects are collections of properties and methods; each object has its own name and is an
instance of a particular class. Built-in objects are predefined in the ActionScript language. For
example, the built-in Date object provides information from the system clock

Packages are directories that contain one or more class files, and reside in a designated classpath
directory

Target paths are hierarchical addresses of movie clip instance names, variables, and objects in a
SWF file. You name a movie clip instance in the movie clip Property inspector. (The main
Timeline always has the name _root.) You can use a target path to direct an action at a movie clip
or to get or set the value of a variable.

Metaprogramming @ Ruby

2007-02-23T20:56:00.000-08:00

Metaprogramming is the writing of programs that write or manipulate other programs (or themselves) as their data or that do part of the work that is otherwise done at run time during compile time. In many cases, this allows programmers to get more done in the same amount of time as they would take to write all the code manually.

The language in which the metaprogram is written is called the metalanguage. The language of the programs that are manipulated is called the object-language. The capacity of a programming language to be its own meta-language is called reflexivity.

Not all metaprogramming involves generative programming. If programs are modifiable at runtime (as in Lisp, Python, Smalltalk, Ruby, PHP, Perl, Tcl and other languages), then techniques can be used to accomplish metaprogramming without actually generating source code.

still more rails

2007-02-22T04:27:00.000-08:00

URL routing
An incoming URL always maps to some action within a controller. A controller is simply a Ruby class, and each action implemented by the controller is a public method within the controller class. The default mapping from URL to action method is (in "Rails-speak"):

/:controller/:action/:id

If the default URL routing does not meet your needs, you can easily specify your own routing rules, even using regular expressions

Rails routing rules are Ruby code. Here is an example:

map.connect 'date/:year/:month/:day',
:controller => 'blog',
:action => 'by_date',
:month => nil,
:day => nil,
:requirements => {:year => /\d{4}/,
:day => /\d{1,2}/,
:month => /\d{1,2}/}With this routing rule, the following URLs are valid:

http://myblog.com/date/2005
http://myblog.com/date/2005/08
http://myblog.com/date/2005/08/01

This rule decomposes a URL containing a date that, perhaps, a blog might use to display the postings for a particular date. A URL that matches this form will map to the BlogController class and the by_date method. The parameter hash will contain values for a four-digit year (/\d{4}/ is a Ruby regular expression), a two-digit month, and a two-digit day. Further, the month and day are optional; if no values are present, the parameter hash will contain the default value of nil.

Filters allow you to run preprocessing code before Rails executes an action and post-processing code after it completes an action. They are useful for such things as caching or authentication before calling the action, and compression or localization of the response after calling an action. The before_filter processing can either allow the action to be called normally by returning true, or abort the action by returning false (or by performing a render or redirect operation).

http://www.onlamp.com/pub/a/onlamp/2005/10/13/what_is_rails.html?page=5

More Rails

2007-02-20T21:23:00.000-08:00

Class names are mixed case (each word
starts with a capital letter, and there are no breaks). Table names (and, as
we’ll see later, variable names and symbols) are lowercase, with an underscore
between words

Over in app/controllers you’ll find a file called application.
rb. This file is used to establish a context for the entire application.
By default, it contains an empty definition of class ApplicationController.

If we end a piece of
embedded Ruby with -%> (note the extra minus sign), ERb will suppress the
newline that follows. That means embedded Ruby that doesn’t generate
any output won’t end up leaving extraneous blank lines in the output.

A commonly used method of array objects is <<, which appends a value to
its receiver.

The session construct stores the objects that you want to keep around
between browser requests. To make this work, Rails has to take these
objects and store them at the end of one request, loading them back
in when a subsequent request comes in from the same browser. To
store objects outside the running application, Rails uses Ruby’s serialization
mechanism, which converts objects to data that can be loaded back in.

Rails has a convenient way of dealing with
errors and error reporting. It defines a structure called a flash. A flash is a
bucket (actually closer to a Hash), into which you can store stuff as you process
a request. The contents of the flash are available to the next request
in this session before being deleted automatically. Typically the flash is
used to collect error messages

The flash information is accessible within the views by using the @flash instance variable.

Why couldn’t we just store the error in any old instance variable? Remember
that a redirect is sent by our application to the browser, which then
sends a new request back to our application. By the time we receive that
request, our application has moved on—all the instance variables from
previous requests are long gone. The flash data is stored in the session in
order to make it available between requests.

A helper is simply code in a module that is automatically included into your views.
You define helper files in app/helpers. A helper named xyz_helper.rb defines
methods that will be available to views invoked by the xyz controller. If
you define helper methods in the file app/helpers/application_helper.rb, those
methods will be available in all views.

model objects perform two roles: they map data into and out of the
database, but they are also just regular objects that hold business data.
They affect the database only when you tell them to, typically by calling
save( ).

The render_component( ) method invokes the given action and substitutes
the output it renders into the current view.

one way of handling subroutines at the view level is by using components to show the contents of a page on some other page. A lighter-weight way of doing the same thing is using a partial template. Unlike the component-based approach, a partial template
has no corresponding action; it’s simply a chunk of template code
that has been factored into a separate file

We know how to create new rows in a database table; we create an action,
put a form into a view, and invoke the model to save data away.

Inside a Rails controller, the request information is available in the attribute request. We can check the request type using the methods get?( ) and post?( ).

form_tag needs no parameters, as it defaults to submitting the form back
to the action and controller that rendered the template

Ruby’s attr_accessor creates a read/write attribute in the model.

rails

2007-02-19T22:30:00.000-08:00

A Rails scaffold is an autogenerated framework for manipulating a model.
When we run the generator, we tell it that we want a scaffold for a particular
model (which it creates) and that we want to access it through a given
controller (which it also creates).

All scaffold-generated applications use the stylesheet scaffold.css in the
directory public/stylesheets.

The scaffold generator automatically makes use of Rails’ built-in
pagination helper. This breaks the lists of products into pages of 10 entries
each and automatically handles navigation between pages

In Rails, a model is automatically mapped to a database table whose name is the plural form of the model’s class.

The model layer is the gatekeeper between the world of code and the
database. Nothing to do with our application comes out of the database or
gets stored back into the database that doesn’t first go through the model.
This makes it an ideal place to put all validation; it doesn’t matter whether
the data comes from a form or from some programmatic manipulation in
our application. If the model checks it before writing to the database, then
the database will be protected from bad data.

Delete vs Truncate @ SQL

2007-01-30T21:20:00.000-08:00

SQL Server
TRUNCATE is a DDL command and cannot be rolled back. All of the memory space is released back to the server.
DELETE is a DML command and can be rolled back.

Both commands accomplish identical tasks (removing all data from a table), but TRUNCATE is much faster

TRUNCATE : You can't use WHERE clause
DELETE : You can use WHERE clause

Truncate = Delete+Commit -so we cant roll back
Truncate is a Transcation control language

Truncate: Drop all object's statistics and marks like High Water Mark, free extents and leave the object really empty with the first extent.
Delete: You can keep object's statistics and all allocated space.

Truncate will write only one query in the ldf file to remove whole data unlike the Delete query which will write one query per record in the ldf file

You cannot use TRUNCATE TABLE on a table referenced by a FOREIGN KEY constraint; instead, use DELETE statement without a WHERE clause. Because TRUNCATE TABLE is not logged, it cannot activate a trigger.

http://www.geekinterview.com/question_details/425

MYSQL

TRUNCATE TABLE empties a table completely. Logically, this is equivalent to a DELETE statement that deletes all rows, but there are practical differences under some circumstances.

For InnoDB before version 5.0.3, TRUNCATE TABLE is mapped to DELETE, so there is no difference. Starting with MySQL 5.0.3, fast TRUNCATE TABLE is available. However, the operation is still mapped to DELETE if there are foreign key constraints that reference the table. (When fast truncate is used, it resets any AUTO_INCREMENT counter. From MySQL 5.0.13 on, the AUTO_INCREMENT counter is reset by TRUNCATE TABLE, regardless of whether there is a foreign key constraint.)

For other storage engines, TRUNCATE TABLE differs from DELETE in the following ways in MySQL 5.0:

Truncate operations drop and re-create the table, which is much faster than deleting rows one by one.

Truncate operations are not transaction-safe; an error occurs when attempting one in the course of an active transaction or active table lock.

The number of deleted rows is not returned.

As long as the table format file tbl_name.frm is valid, the table can be re-created as an empty table with TRUNCATE TABLE, even if the data or index files have become corrupted.

The table handler does not remember the last used AUTO_INCREMENT value, but starts counting from the beginning. This is true even for MyISAM and InnoDB, which normally do not reuse sequence values.

Since truncation of a table does not make any use of DELETE, the TRUNCATE statement does not invoke ON DELETE triggers.

DOM @ XML

2007-01-29T01:37:00.000-08:00

The XML Document Object Model (XML DOM) defines a standard way for accessing and manipulating XML documents.

The DOM presents an XML document as a tree-structure (a node tree), with the elements, attributes, and text defined as nodes.

Parsing the XML DOM

To manipulate an XML document, you need an XML parser. The parser loads the document into your computer's memory. Once the document is loaded, its data can be manipulated using the DOM. The DOM treats the XML document as a tree.

There are some differences between Microsoft's XML parser and the XML parser used in Mozilla browsers. In this tutorial we will show you how to create cross browser scripts that will work in both Internet Explorer and Mozilla browsers

Microsoft's XML Parser
Microsoft's XML parser is a COM component that comes with Internet Explorer 5 and higher. Once you have installed Internet Explorer, the parser is available to scripts.

Microsoft's XML parser supports all the necessary functions to traverse the node tree, access the nodes and their attribute values, insert and delete nodes, and convert the node tree back to XML.

To create an instance of Microsoft's XML parser, use the following code:

JavaScript:

var xmlDoc=new ActiveXObject("Microsoft.XMLDOM");

The first line of the script above creates an instance of the XML parser. The second line turns off asynchronized loading, to make sure that the parser will not continue execution of the script before the document is fully loaded. The third line tells the parser to load an XML document called "note.xml".

XML Parser in Mozilla, Firefox, and Opera
Mozilla's XML parser supports all the necessary functions to traverse the node tree, access the nodes and their attribute values, insert and delete nodes, and convert the node tree back to XML.

To create an instance of the XML parser in Mozilla browsers, use the following code:

JavaScript:

var xmlDoc=document.implementation.createDocument("ns","root",null);

The first parameter, ns, defines the namespace used for the XML document. The second parameter, root, is the XML root element in the XML file. The third parameter, null, is always null because it is not implemented yet

The following code fragment loads an existing XML document ("note.xml") into Mozillas' XML parser:

var xmlDoc=document.implementation.createDocument("","",null);
xmlDoc.load("note.xml");

The first line of the script above creates an instance of the XML parser. The second line tells the parser to load an XML document called "note.xml".

Web 2.0 huh

2007-01-08T10:42:00.000-08:00

Social Software

2007-01-04T09:10:00.000-08:00

List of Social Softwares
http://en.wikipedia.org/wiki/List_of_social_software

Introduction-to-the-Read-Write-Web

2007-01-04T09:02:00.000-08:00

Misc things @ JavaScript

2007-01-03T23:49:00.000-08:00

Ok/Cancel box:

if (confirm('Like cookies?')) { document.write('you like cookies!') }

The buttons on a confirm box cannot be changed, nor can you specify a
default button

Session object
The Session object is a host object (i.e. not native) that is made
available to JavaScript code processed on the server in an ASP
pre-processing page.

under ASP I believe the Session object's
properties are accessed using ' ( ) ' notation, so in an ASP page,
Session("UserID") = "" is valid.

The ASP Session object cannot be acessed by code running on the client. It is only available to that JavaScript which
runs on the server **before** the ASP page is sent to the client.

An Iframe is a frame, so to get to the page that holds the Iframe you need
'parent'. From the popupwindow to the first window, use the word 'opener'.
So you need parent.opener...
But JS will only communicate between all these windowobjects if they all
reside in the same domain.

Frames @ HTML

2006-12-31T00:09:00.000-08:00

With frames, you can display more than one Web page in the same browser window.
With frames, you can display more than one HTML document in the same browser window. Each HTML document is called a frame, and each frame is independent of the others.

The disadvantages of using frames are:
The web developer must keep track of more HTML documents
It is difficult to print the entire page

The Frameset Tag
The <.frameset> tag defines how to divide the window into frames
Each frameset defines a set of rows or columns
The values of the rows/columns indicate the amount of screen area each row/column will occupy

The Frame Tag
The frame tag defines what HTML document to put into each frame

In the example below we have a frameset with two columns. The first column is set to 25% of the width of the browser window. The second column is set to 55% of the width of the browser window and third column to remaining 20%. The HTML document "aframe.htm" is put into the first column, the HTML document "bframe.htm" is put into the second column and the HTML document "cframe.html" into the third column:
<.frameset cols="25%,55%,20%">
<.frame src="aframe.htm">
<.frame src="bframe.htm">
<.frame src="cframe.htm">

If a frame has visible borders, the user can resize it by dragging the border. To prevent a user from doing this, you can add noresize="noresize" to the <.frame> tag.

Add the <.noframes> tag for browsers that do not support frames.

You can't use the <.body> tags together with the <.frameset> tags! However, if you add a <.noframes> tag containing some text for browsers that do not support frames, you will have to enclose the text in <.body> tags!

A Quick Teaser

2006-12-29T23:55:00.000-08:00

Each child in a family has at least 5 brothers and 4 sisters. What is the smallest number of children the family might have?

Delicious is hiring

2006-12-29T05:50:00.001-08:00

Yes, that is the news.

I happened to visit the delicious blog (http://blog.del.icio.us)and while surfing came across an article with heading help wanted only to realise that they are hiring and here's what was written in that article

It's hiring season again at del.icio.us, and we're looking to bring a few more engineers on board at our cushy Santa Clara offices. If you are a PHP god, javascript hacker, a database wizard, a UI guru, or a uber C++ ninja, let us know. As the team is so small, entrepreneurial spirit and willingness to learn new things are also a requirement. Finally, enthusiasm for del.icio.us is a BIG plus, as we're a small team where everyone has a voice and the chance to affect the direction of the product.

Perks are vast and too numerous to spell out here, but include a team t-shirt, a formidable supply of stickers and bookmarks, infinite coffee, and the opportunity to learn a lot, have fun, drink infinite coffee, and change the world

refer to:
http://blog.del.icio.us/blog/2006/11/help_wanted.html
for details

Books on Entrepreneurship

2006-12-29T05:42:00.000-08:00

Here's a list of books on Entrepreneurship compiled for your reference.

* The High-Performance Entrepreneur by Subroto Bagchi
* The Art of the Start by Guy Kawasaki
* Zero to One Million by Ryan P. M. Allis
* Zero to IPO by David Smith
* Rich Dad's Guide to Investing by Robert Kiyosaki
* New Venture Creation by Jeffrey Timmons
* Good to Great by Jim Collins
* The E-Myth by Michael Gerber
* The Young Entrepreneurs'Edge by Jennifer Kushnell
* The Young Entrepreneur's Guide to Starting and Running a Business by Steve Mariotti
* The Portable MBA in Entrepreneurship by William D. Bygrave
* Innovation and Entrepreneurship by Peter Drucker
* Good to Great by Jim Collins
* At Work with Thomas Edison by Blain McCormick
* Multiple Streams of Income by Robert G. Allen
* On Entrepreneurship by Harvard Business Review
* Entrepreneurship.com by Tim Burns
* Fire in the Belly - an exploration of the entrepreneurial spirit by Yanky Fachler
* Rich Dad Poor Dad by Robert Kiyosaki

Hope they'll do some value addition

Web2.0 presentation @ SlideShare

2006-12-28T00:40:00.001-08:00

Print methods and doc strings @ Python

2006-12-27T05:39:00.000-08:00

def info(object, spacing=10, collapse=1):
"""
Takes module, class, list, dictionary, or string."""
methodList =[method for method in dir(object) if callable(getattr(object, method))]
processFunc =collapse and (lambda s: " ".join(s.split())) or (lambda s:s)
print "\n".join(["%s=%s" % (method.ljust(spacing),processFunc(str(getattr(object, method).__doc__)))
for method in methodList])
if __name__=="__main__":
print info.__doc__

Sum of elements of array @ Python

2006-12-26T23:34:00.000-08:00

array = input('Enter the array')
sum = 0
for i in array:
sum = sum + i
print "sum of elements of array is", sum

StringComparison @ Python

2006-12-26T22:54:00.000-08:00

a = raw_input('Enter first String')
b = raw_input('Enter second String')

l1 = len(a)
l2 = len(b)

if (l1==l2):
for i in range(l1):
if (a[i]==b[i]):
l1 = l1-1
if(l1==0):
print "Same"
else:
print "Different"
break

else:
print "Different"

PHP vs ASP

2006-12-25T20:16:00.001-08:00

Speed
PHP is faster and more stable than ASP. ASP is built on a COM-based architecture so when ever a programme tries to connect to a database or file he calls a COM object. When that COM object tries to access the file system it calls up yet another COM object. All these COM overheads add up and slows things down.

In PHP modules, everything runs in PHP's memory space. This means that PHP code will run faster because there is no overhead of communicating with different COM objects in different processes. In this case too, ASP is slower and more memory intensive than PHP's model because each ASP language compiler runs in its own process.

Price
PHP installations are far cheaper to install than ASP installations. PHP runs great on Linux which is free, on the other hand ASP runs on the IIS Server (Internet Information Server) which need's Windows N.T/2000/XP, any of which costs a lot, especially when compared to the price of PHP, nothing.

Apart from that ASP mostly uses MS-SQL Server as the back end which again is expensive, Where as PHP programmes mostly use MySQL which is FREE!

Extras
With ASP, if you need to upload files, then you need a third party component ASPuplod, if you want to send mail or encrypt passwords you need another component and so on. Each of these components has to be bought.

In PHP, if you want to FTP, encrypt passwords in MD5, or send email from a web page, you do not need any extra components as they are all built-in, which is, incidentally, another speed increase. Because everything is built-in, there is no extra layer of COM objects and access to email, for example, is faster than in ASP. Since PHP is Open-Source there are lots of plug-ins and lots of sample code.

Platform Support
PHP runs on Mac OS X, Windows, Win NT, Linux, Solaris, Unix, BSD etc.
ASP runs on Windows, under MicrosoftÕs IIS server, but there are a couple of projects that allow ASP to run on other platforms and servers but guess what, most of them cost money.

PySpotting

2006-12-23T09:03:00.001-08:00

Choose Python. Choose readability.
Choose the simple over the complex and
the complex over the complicated. Choose
dynamic typing. Choose duck typing.
Choose decorators. Choose generators.
Choose metaclasses if you don't value
your sanity. Choose to import this. Choose
an almost-fanatical devotion to the BDFL,
unless he comes up with something like
optional static typing, in which case choose
to whine about it in your blog until he stops.
Choose Effbot. Choose Timbot. Choose
wx. Choose to come up with a bloody implementation
before spouting off on
comp.lang.python or Python-Dev. Choose
the explicit rather than the implicit. Choose
one obvious way to do it, especially if you
are Dutch. Choose list comprehensions.
Choose Paul Graham's essays and
s/LISP/Python/g. Choose Jython when
your marketing people choose Java.
Choose speed of development over speed
of execution, but when in doubt, import
psyco. Choose to finish early and laugh at
your colleagues as they waste their miserable
lives bowing down in subservience to
that sadistic little C++ compiler.
Choose Python.
Choose your __future__

The General Query Log @ Mysql

2006-12-23T05:28:00.000-08:00

The general query log is a general record of what mysqld is doing. The server writes information to this log when clients connect or disconnect, and it logs each SQL statement received from clients. The general query log can be very useful when you suspect an error in a client and want to know exactly what the client sent to mysqld.

mysqld writes statements to the query log in the order that it receives them, which might differ from the order in which they are executed. This logging order contrasts to the binary log, for which statements are written after they are executed but before any locks are released. (Also, the query log contains all statements, whereas the binary log does not contain statements that only select data.)

To enable the general query log, start mysqld with the --log[=file_name] or -l [file_name] option.

If no file_name value is given for --log or -l, the default name is host_name.log in the data directory.

Server restarts and log flushing do not cause a new general query log file to be generated (although flushing closes and reopens it). On Unix, you can rename the file and create a new one by using the following commands:
shell> mv host_name.log host_name-old.log
shell> mysqladmin flush-logs
shell> cp host_name-old.log backup-directory
shell> rm host_name-old.log

On Windows, you cannot rename the log file while the server has it open. You must stop the server and rename the file, and then restart the server to create a new log file.

String Methods @ Python

2006-12-23T05:08:00.000-08:00

strip( [chars])

Return a copy of the string with the leading and trailing characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a prefix or suffix; rather, all combinations of its values are stripped:
>>> ' spacious '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

split( [sep [,maxsplit]])

Return a list of the words in the string, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done. (thus, the list will have at most maxsplit+1 elements). If maxsplit is not specified, then there is no limit on the number of splits (all possible splits are made). Consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, "'1„2'.split(',')"returns "['1', '', '2']"). The sep argument may consist of multiple characters (for example, "'1, 2, 3'.split(', ')" returns "['1', '2', '3']"). Splitting an empty string with a specified separator returns "['']".

If sep is not specified or is None, a different splitting algorithm is applied. First, whitespace characters (spaces, tabs, newlines, returns, and formfeeds) are stripped from both ends. Then, words are separated by arbitrary length strings of whitespace characters. Consecutive whitespace delimiters are treated as a single delimiter ("'1 2 3'.split()" returns "['1', '2', '3']"). Splitting an empty string or a string consisting of just whitespace returns an empty list.

List Manipulation @ Python

2006-12-23T04:18:00.000-08:00

Just think of python variables as labels to objects, not as storing stuff or even references to something.

In fact you don't event need copy module... since when you slice a list it returns a new list object with the objects needed, you can use a slice to give a new list with all objects, a copy:

>>> a = [1, 2, 3]
>>> b = [a[:], a[:], a[:]]
>>> b
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
>>> b[1][1]
2
>>> b[1][1] = 4
>>> b
[[1, 2, 3], [1, 4, 3], [1, 2, 3]]

You get changed only the 2nd list, because you created three copies:

>>> a is a
True
>>> a[:] is a[:]
False
>>> a[:] == a[:]
True

The same happen for elementary types, they are no exception, but the behavior with them may be different because they are immutable and may be the same object. With integers, for instance, in this case, with small integers,

>>> x = 10
>>> y = x - 1
>>> z = x - 1
>>> y == z
True
>>> y is z
True

Both y and z are integers with the same value and are the same object. But with large integers, the same may not happen:

>>> x = 123456789
>>> y = x - 1
>>> z = x - 1
>>> y == z
True
>>> y is z
False

Here they have the same value, but they are not the same object. Since they are immutable, it doesn't matter, just to keep in mind to always think if you want to make comparisons by value (==) or by identity (is)

"==" compare by value, if both objects have the same value, while "is" compare by identity, if they are the same object.

Example, here x and y have the same value, but are not the same objects.

>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x == y
True
>>> x is y
False

Here x and y are the same object, and therefore have the same value:
>>> x = y = [1, 2, 3]
>>> x == y
True
>>> x is y
True

But, when you deal with immutable objects, Python have an internal cache, so they may be the same object, but you have no guarantee, so be careful if you want to check by value or identity...

Enabling Task Manager @ Windows

2006-12-22T23:09:00.000-08:00

Click Run
· Enter gpedit.msc in the Open box and click OK
· In the Group Policy settings window
o Select User Configuration
o Select Administrative Templates
o Select System
o Select Ctrl+Alt+Delete options
o Select Remove Task Manager
o Double-click the Remove Task Manager option
that will do

XML Data island @ XML

2006-12-22T03:10:00.000-08:00

In an HTML document, you can embed the XML file above with the xml tag. The id attribute of the xml tag defines an ID for the data island, and the src attribute points to the XML file to embed:

The datasrc attribute of the tag binds the HTML table element to the XML data island. The datasrc attribute refers to the id attribute of the data island.

tags cannot be bound to data, so we are using tags. The tag allows the datafld attribute to refer to the XML element to be displayed.

To manipulate an XML document, you need an XML parser. The parser loads the document into your computer's memory. Once the document is loaded, its data can be manipulated using the DOM. The DOM treats the XML document as a tree.

There are some differences between Microsoft's XML parser and the XML parser used in Mozilla browsers.

Microsoft's XML Parser
Microsoft's XML parser is a COM component that comes with Internet Explorer 5 and higher. Once you have installed Internet Explorer, the parser is available to scripts.
Microsoft's XML parser supports all the necessary functions to traverse the node tree, access the nodes and their attribute values, insert and delete nodes, and convert the node tree back to XML.
To create an instance of Microsoft's XML parser, use the following code:

JavaScript:
var xmlDoc=new ActiveXObject("Microsoft.XMLDOM");

VBScript:
set xmlDoc=CreateObject("Microsoft.XMLDOM")

ASP:
set xmlDoc=Server.CreateObject("Microsoft.XMLDOM")
The following code fragment loads an existing XML document ("note.xml") into Microsoft's XML parser:
var xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
xmlDoc.async="false";
xmlDoc.load("note.xml");
The first line of the script above creates an instance of the XML parser. The second line turns off asynchronized loading, to make sure that the parser will not continue execution of the script before the document is fully loaded. The third line tells the parser to load an XML document called "note.xml".

XML Parser in Mozilla, Firefox, and Opera

Mozilla's XML parser supports all the necessary functions to traverse the node tree, access the nodes and their attribute values, insert and delete nodes, and convert the node tree back to XML.
To create an instance of the XML parser in Mozilla browsers, use the following code:

JavaScript:
var xmlDoc=document.implementation.createDocument("ns","root",null);
The first parameter, ns, defines the namespace used for the XML document. The second parameter, root, is the XML root element in the XML file. The third parameter, null, is always null because it is not implemented yet.
The following code fragment loads an existing XML document ("note.xml") into Mozillas' XML

parser:
var xmlDoc=document.implementation.createDocument("","",null);
xmlDoc.load("note.xml");
The first line of the script above creates an instance of the XML parser. The second line tells the parser to load an XML document called "note.xml".

http://www.w3schools.com/xml/xml_data_island.asp

Repeat @ Python

2006-12-22T00:54:00.000-08:00

class repeat(__builtin__.object)
repeat(element [,times]) -> create an iterator which returns the element
for the specified number of times. If not specified, returns the element
endlessly.

Methods defined here:

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__iter__(...)
x.__iter__() <==> iter(x)

__len__(...)
x.__len__() <==> len(x)

__repr__(...)
x.__repr__() <==> repr(x)

next(...)
x.next() -> the next value, or raise StopIteration

----------------------------------------------------------------------
Data and other attributes defined here:

__new__ =
T.__new__(S, ...) -> a new object with type S, a subtype of T

Dictionary @ Python

2006-12-21T22:52:00.000-08:00

> Python dict is a hash table, isn't it? Yup.
> I know that hashtable has the concept of "bucket size" and "min bucket
> count" stuff,

Some implementations of hash tables do. Python's does not. Python's uses what's called "open addressing" instead.

> and they should be configurable so I can set them to the proper value
> when I know how many items I'm going to handle.
> If these two values can't be set, the hashtable will give them default
> values. When there are more and more items being added to the
> hashtable, it increase its buckets and copy the old items into the new
> one and re-calculate the hash value of each item.

That's several distinct claims, each of which is true of some hash table implementations but not of others. Python's implementation has no "buckets", so all that's simply irrelevant. Python's implementation (not all do) saves the hash value of each item, so when it does need to grow (or shrink) the space allocated to the table, it does not need to recalculate the hash value of any item.
You should also note that copying a dict key or value (no matter of what type) consists in its entirety of copying one machine address (a 4- or 8-byte pointer, depending on platform).

> I think this will waste some time doing the increasing-copying thing.

It does take time to resize. "Waste" is a value judgment ;-)
> If I know I'm going to handle about 20000 items, I can set the size of
> hashtable to 30000.
> So, can I do this in python?

You can't. Unless you build up to 20000 items over and over (many thousands of times), it's unlikely you'd be able to measure the time difference even if you could.

Ex:

1)creating the dictionary with no other Python overhead

import random; r = [ random.random() for i in range(20000)]; d = dict.fromkeys(r)

2)Creating the dictionary using a Python for loop
import random; r = [ random.random() for i in range(20000)];d={} ;for k in r: d[k] = None

WebSite vs Web Application

2006-12-19T21:46:00.000-08:00

WEB APPLICATION:
An application that is delivered using Internet technology and meets one or more of the following conditions:
Utilizes a database (such as Oracle or SQL Server)
Is developed using an application development tool (such as Oracle Internet Developer Suite or Visual Studio)
Extracts data from multi-record files
Requires a constantly running server process (such as Newsgroups and Chatrooms)
Stores input data from data entry screens or web forms
Depending on its requirements, a web application may be an Internet Application or an Intranet Application.

WebSite vs Web Application:
Historically, a website is any site on the internet (whether simple or complex) in which visitors can go. Therefore, whether it's a static site (the visitor can only read information or research a topic,) or whether it's a dynamic site (such as an online e-commerce store that can be managed by the store owner online) it's considered a website. A web application is also considered a website. However, web applications are web-based software programs, often as powerful as software applications made for your home or business computer. For instance, many online e-commerce stores are web applications. They are software programs that run on the web and are accessed via the internet instead of running strictly on your PC

JavaScript: Why parseInt(08) & parseInt(09) is showing the value 0 ?

2006-12-19T02:42:00.000-08:00

That's because "08" and "09" are invalid numbers, in octal.
The parseInt() function actually allows two arguments, the string to
parse and a radix, which is optional. This radix value allows you to
convert a binary (base 2), hexadecimal (base 16) or other base string to
a decimal integer. For example
parseInt("FF", 16);
returns 255. This is very useful for parsing things like HTML color values.
Most people aren't aware of the optional radix argument. The problem is
that if you leave it off, the function will doesn't necessarily assume
you want a decimal (base 10) conversion. Instead it checks the input
string (the first argument) and if it starts with "0x" it assumes it's a
hexadecimal value. If it starts with "0" - not followed by an "x" - it
takes it as an octal value. This follows the JavaScript convention for
numeric constants. If you code
var x = 0x18;
alert(x);
it will display 24 which is the decimal equivalent of the hex number
"18". Likewise,
var x = 014;
alert(x);
displays 12 which is the decimal value of the octal number "14".
As you should know, hexadecimal uses the digits 0-9 and the letters A-F,
16 in all. Octal is base 8, so only the digits 0-7 are valid. Hence,
"08" and "09" are not valid octal numbers and the function returns zero
just as it would for "xyz" in decimal - it's not a valid number.
To avoid this, always add the second argument, in this case
parseInt("08", 10);
returns 8 (decimal), as desired.

Enumerate function @ Python

2006-12-18T08:28:00.000-08:00

class enumerate(object)

| enumerate(iterable) -> iterator for index, value of iterable

|

| Return an enumerate object. iterable must be an other object that supports

| iteration. The enumerate object yields pairs containing a count (from

| zero) and a value yielded by the iterable argument. enumerate is useful

| for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...

|

| Methods defined here:

|

| __getattribute__(...)

| x.__getattribute__('name') <==> x.name

|

| __iter__(...)

| x.__iter__() <==> iter(x)

|

| next(...)

| x.next() -> the next value, or raise StopIteration

|

| ----------------------------------------------------------------------

| Data and other attributes defined here:

|

| __new__ =

| T.__new__(S, ...) -> a new object with type S, a subtype of T

ex::

1)
for index,word in enumerate(range(10)):
... print index,word
...
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9

2)
for index,word in enumerate(range(10)):
... print "%s %f" % (index,word)
...
0 0.000000
1 1.000000
2 2.000000
3 3.000000
4 4.000000
5 5.000000
6 6.000000
7 7.000000
8 8.000000
9 9.000000