Web Development

It’s getting harder to be a Wikipedia-hater. The user-generated and -edited online encyclopedia—which doesn’t even require contributors to register—somehow holds its own against the Encyclopedia Britannica in accuracy, a Nature study concluded, and has many times more entries. But even though people are catching up to the idea that Wikipedia is a force for good, there are still huge misconceptions about what makes the encyclopedia tick. While Wikipedia does show the creative potential of online communities, it’s a mistake to assume the site owes its success to the wisdom of the online crowd.

Social-media sites like Wikipedia and Digg are celebrated as shining examples of Web democracy, places built by millions of Web users who all act as writers, editors, and voters. In reality, a small number of people are running the show. According to researchers in Palo Alto, 1 percent of Wikipedia users are responsible for about half of the site’s edits. The site also deploys bots—supervised by a special caste of devoted users—that help standardize format, prevent vandalism, and root out folks who flood the site with obscenities. This is not the wisdom of the crowd. This is the wisdom of the chaperones.

The same undemocratic underpinnings of Web 2.0 are on display at Digg.com. Digg is a social-bookmarking hub where people submit stories and rate others’ submissions; the most popular links gravitate to the site’s front page. The site’s founders have never hidden that they use a “secret sauce”—a confidential algorithm that’s tweaked regularly—to determine which submissions make it to the front page. Historically, this algorithm appears to have favored the site’s most active participants. Last year, the top 100 Diggers submitted 44 percent of the site’s top stories. In 2006, they were responsible for 56 percent.

It’s hard to avoid the conclusion that Digg—a site meant to “collectively determine the value of content“—is largely run by 100 people. The influence of these members was particularly apparent last month. After Digg tweaked its secret sauce, top contributors noticed a decline in influence—fewer of their submissions became top stories. The super Diggers published an open letter of grievances and threatened to boycott the site. The changes in the algorithm, the Digg execs said, were meant to bring a more diverse set of stories to the site, and they begged for patience from the top Digg contributors. (Thus far, a shaky truce has endured.) The takeaway: Digg’s brass believe that the site, which purports to be the product of a broad-based community, will cease to run smoothly if a microscopic percentage of its user base stops participating.

At both Digg and Wikipedia, small groups of users have outsized authority. In the case of Wikipedia, this authority is both organic and institutionalized. A small segment of highly active users author the majority of the site’s content; there are also elected site administrators who have the power to protect pages, block the IP addresses of problem users, and otherwise regulate Wikipedia’s operations. At Digg, active users have more of a de facto authority over the site’s goings-on (though there are persistent rumors that the site has “secret moderators” who delete content). But officially speaking, while the site’s algorithm seems to favor devoted users, no individual Digger has the power to unilaterally delete a post.

While both sites effectively function as oligarchies, they are still democratic in one important sense. Digg and Wikipedia’s elite users aren’t chosen by a corporate board of directors or by divine right. They’re the people who participate the most. Despite the fairy tales about the participatory culture of Web 2.0, direct democracy isn’t feasible at the scale on which these sites operate. Still, it’s curious to note that these sites seem to have the hierarchical structure of the old-guard institutions they’ve sought to supplant.

This top-heavy structure of social-media sites isn’t news to researchers and technophiles. Wikipedia co-founder Jimmy Wales has acknowledged that what he expected to be an “80-20″ rule—a system where 20 percent of people control 80 percent of the resources—in fact understates the site’s top-heaviness. Palo Alto Research Center’s Ed Chi, the scientist who determined that 1 percent of Wikipedians author half of the content, told me he originally hypothesized that the site’s most energetic editors were acting as custodians. Chi guessed that these users mostly cleaned up after the people who provided the bulk of the encyclopedia’s facts. In reality, he found the opposite was true (PDF). People who’ve made more than 10,000 edits add nearly twice as many words to Wikipedia as they delete. By contrast, those who’ve made fewer than 100 edits are the only group that deletes more words than it adds. A small number of people are writing the articles, it seems, while less-frequent users are given the tasks of error correction and typo fixing.

This isn’t the kind of people-working-together image that Digg and Wikipedia promote. Of course, Wikipedia requires some level of administration—otherwise, the site would crash under the weight of additions and deletions to the George W. Bush page. But that doesn’t explain the kind of territorialism—the authorial domination by 1 percent of contributors—on the site’s pages. Is this a necessary artifact of operating an open-access site? Or is it possible to build a clearinghouse for high-quality, user-generated content without giving too much power to elite users and secret sauces?

The moderation system at the tech blog Slashdot is perhaps the best example on the Web of a middle way. Slashdot, which draws on links submitted by readers, ordains active contributors with limited power to regulate comments and contributions from other users. Compared with Wikipedia, which requires supreme devotion from its smaller core of administrators, Slashdot makes it easy to become a moderator. Giving large numbers of people small chunks of responsibility has proven effective in eliminating trolls and flame wars in the comment section. Still, the authority any one moderator commands is small, and the site’s official poobahs maintain control over which stories are featured at the top of the site. “These things are far from utopian,” says founder Rob Malda, aka CmdrTaco. “Slashdot tends to have a lot of ‘Microsoft does something bad’ stories. If I let the community run the whole thing, we’d have a lot more. But I don’t want Slashdot to be the ‘Microsoft Sucks’ page. It’s just one of many subjects.”

Another compelling model comes from Helium.com, a Wikipedia-like repository of articles and editorials. Its founder, Silicon Valley veteran Mark Ranalli, compares his site to a capitalist version of Wikipedia. On Helium, contributors compete to have the top-ranked article on a given subject. As soon as you write an article, you’re invited to pick your favorite of two articles on a similar subject. Requiring someone to write before he or she rates creates a more stable system: Rather than create a caste of creators and a caste of peons, Helium encourages everyone to do everything.

Every model has its drawbacks. Unlike Wikipedia, Helium doesn’t lend itself to comprehensive articles drawing on many sources. Nor is Slashdot free of moron commenters, though its quotient is significantly lower than on any unmoderated message board. It’s refreshing, though, that these sites acknowledge that Web 2.0 isn’t a fairy-tale democracy without letting themselves become dictatorships. Digg and Wikipedia would do well to stop pretending they’re operated by the many and start thinking of ways to rein in the power of the few.

Via Slate Magazine

From Official Google blog:

The fundamental problem with information is that there’s too much of it, and this is probably why we all go to our trusted sources to learn what we really need to know. Your sources filter out the noise and present the most interesting bits to you in a useful way. For many of us, these sources include newspapers, magazines, and of course blogs. We built Google Reader as a way for you to see all of your online sources in one place.

So if you want to keep up with the chatter about the new iPods or Superbad, now you can. We’ve added a familiar search box to the top of Google Reader so you can search across all the blogs and sites to which you’re subscribed.

Read more: Find a needle in a feedstack with Google Reader

There is a collection of pictures of different Windows versions. You can see how Windows changed from 1.0 to Vista.

Windows 1.0

Windows 1.01

Windows 2.0

Windows 3.0

Windows 3.1

Windows NT 3.1

Windows 3.11

Windows 95

Windows NT 3.51

Windows 98

Windows NT 4.0

Windows 2000

Windows ME

Windows XP

Windows Vista

We’re hosting an Asia Pacific open house for engineers on Thursday, June 28 from 6-9pm on the Google campus in Mountain View. Ping Li from Accel Partners will moderate a panel discussion by the four directors of our engineering centers in India, Korea, Taiwan, and China. They’ll talk about top tech trends in their respective markets, and we’ll demo products developed in each location. Of course, there will be plenty of food & drink, and a raffle. This should be an informative networking event for Bay Area engineers and entrepreneurs with a technical background.

Read more at Official Google Blog: Asia-Pacific Open House June 28th

Introduction

Recently I needed to write some drivers for the specific USB-scanner. This scanner is working in mode of uninterruptible scan-out with the frequency of 10 shots per second and provides the speed of stream for reading of 3.2Mb\sec.

First the drivers were developed for Linux core version 2.6.15, but later, under the client’s demand, they were adapted for the core version 2.4.26. Surprisingly, it wasn’t hard at all to write drivers fro both core versions. For this purpose you need just to know clearly how USB works and which functions provide interoperation of the driver and USB-device. All the other things are instantiated in core of linux.

The following tasks I see before writing down the following article:

1. telling about basic properties of devices change by USB
2. describing programming interface of the interoperation between driver and USB-device
3. give examples of core functions usage

Hope, the following information is interesting for the system level programmers.

Introduction to USB

Probably, there is no sense to speak about such obvious things, as wide
spread of USB, high speed of an exchange on USB, an opportunity of
hot connection of devices. Already each PC user anyhow has valued the advantages and pluses of USB.

Therefore we shall pass to less obvious things at once: how is USB
arranged inside.

Who is the boss?

One of main concepts of USB is that
there can be only one master in USB-system. It is host-computer. USB-
devices always answer inquiries of a host-computer – they can never
send the information independently.

There is only one exception: after the host has transferred the device in
the suspend-mode, the device can send inquiry remote wakeup. In all
other cases the host forms inquiries, and devices answer on
them.

Direction

Host is always the master, and data exchange should be carried out in
both directions:

* OUT – sending packet with flag OUT, host is sending data to device

* IN - sending packet with flag IN, host is sending enquiry for receipt of data from device.

You just need to adjust to it. Host is sending packet with flag IN just for receiving the data from device. smile

Packets classification in USB

Few packet types could by transferred through USB:
1. Token - enquiry, contains driving information: direction of the operation(IN, OUT), number of the endpoint
2. Data – data packet
3. Handshake – utility packets, may contain confirmation (ACK),
error message, abruption (NACK)
4. Special – service packets, such as PING

More detailed information about packets, mentioned in USB specification, you may read in [2,3]. Let’s view few examples of these packets usage.

Example: sending data to device

Host sends packet Token “OUT”, then packet Data in order to send data to device. If device is ready to process received data, it sends packet Handshake “ACK”, which confirms transaction. If it is busy, it sends refusal – Handshake “NACK”. If any mistake took place, device may not send Handshake.

Example: sending data to host

As told before, device never sends data itself. Only on-request. In order to except data, host sends packet Handshake “IN”. Device may send packet Data on-request, then Handshake “ACK”. Or it may send Handshake “NACK” without sending Data.

Types of data transfer

USB specification defines 4 types of data streams:
1. bulk transfer - assigned for packet data transfer with the packet sizes of 8, 16, 32, 32 for USB 1.1 and 512 for USB 2.0. Algorithm of resending is used (in case of mistakes appearing), and the stream driving is conducted with handshake packets usage. That’s why this type is legal. Both directions IN and OUT are supported.

2. control transfer – assigned for configuring and driving the device. As well as bulk, algorithms of confirmation and resending, that’s why this type provides with guaranteed data exchange. Directions – IN (status) and OUT (setup, control).
3. interrupt transfer - similar to bulk. Packet size - from 1 to 64
byte for USB 1.1 and up to 1024 byte for USB 2.0. This type guarantees, that device is inquired by host in specified interval (this means that host will send it token “IN”). Direction – IN.

4. isochronous transfer - assigned for data transfer without stream driving (without confirmation). Field of application -
audio-streams, video-streams. Packet size – up to 1023 byte for USB
1.1 and up to 1024 byte for USB 2.0. Mistake control is provided (for the excepting side) on CRC16. Directions - IN and OUT.

Endpoint - source/receiver of the data

USB specification defines endpoint (EP), as data source of data receiver. Device may have up to 32 EP: 16 for input and 16 for output.
Access to this or that endpoint happens according to its address.

For example,let us suppose, that host is intended to read data packet from EP4 (fourth endpoint of the device) with the help of “bulk transfer” type. It sends packet token “IN”, where it indicates the address of the endpoint. Corresponding source in the device sends data packet to host. Data packet transfer happens the same way.

Endpoint No.0

EP0 has a special value for USB. It is Control EP. It has to be in each USB-device. This EP uses token “setup”, in order to signalize that sending data coming after it are intended to drive the device. In most cases setup-packet transfer is enough. Nevertheless, device may use data transfer through EP0 as well, e.g. for components’ insertions change, or for receiving of expanded information about the device.

Let’s view setup-packet in details.

EP0: setup-packet

Contents of setup-packet is represented in the following table

Byte (No.)	Name	Mapping
0	bmRequestType	Field for indicating request type, direction, receiver
1	bRequest	Request identifier
2	wValueL	16-byte value wValue, depends on request.
3	wValueH	16-byte value wValue, depends on request.
4	wIndexL	16-byte value wIndex, depends on request.
5	wIndexH	16-byte value wIndex, depends on request.
6	wLengthL	byte quantity, sent after setup-packet.
7	wLengthH	byte quantity, sent after setup-packet.

As you may see in the table above, setup-packet contains 5 fields. bmRequestType and
bRequest specify request, and wValue, wIndex and wLength – its values.

USB specification preserves value range bRequest according to standard requires. Each device is obliged to reply all the standard requires. There are few standard requires in the following table.

bRequest	Name	Description
0×05	Set Address	Installation of the unique address of device in the system
0×06	Get Descriptor	Receipt of information about device. Type of information depends on field wValue.

Other range device may use as it thinks fit. Detailed data is available in [2,3].

Detection of the device

How is device detected when it is freshly connected to system? It was mentioned already, that each device has to provide access to REP0. But besides it has to reply the enquiries indicated in USB specification for EP0. Detection of the device in system happens due to these enquires.

Algorithm of new device detection is as follows:
1. host sends setup-packet “Get Descriptor” (wValue = “device”).
2. host receives identifying information about device
3. host sends setup-packet “Set address”, then device receives unique address in system
4. host sends other setup-packets “Get Descriptor” and receives additional information about device: quantity of EP, power requirements, etc.

USB support in Linux core

Programming interface for interaction with USB devices in Linux core is very simple. Under the simple interface all the algorithms of enquiries sending, confirmation tracking, mistake control, etc. are hidden. All the details, described in previous part are instantiated in Linux core.
In the core all the program files are located in drivers/usb/, and heading files are located in include/linux/. Information represented in this directories is enough to write driver for any USB-device individually.

Driver, interacting to USB-device usually takes the following actions:

1. registration\unloading of the driver
2. registration\removal of the device
3. data exchange: driving and informational.

Let’s examine them in details relating to embedding under the core 2.6.15. For better neatness we need to understand basic principles of UDM [4, 5] which appeared in core 2.6.

Registration\uploading of the driver.

Registration of the USB driver means:
1. filling the structure usb_driver
2. registration of the structure in the system

The structure usb_driver is described in include/linux/usb.h Let’s examine the most important fields of this structure.

struct usb_driver {
// …
const char *name;
int (*probe) (struct usb_interface *intf,
const struct usb_device_id *id);
void (*disconnect) (struct usb_interface *intf);
const struct usb_device_id *id_table;
struct device_driver driver;
// …
};

Evidently, name is the name of driver. id_table is the array of structures
usb_device_id. This list is assigned for definition of connected devices’ conformance to certain parameters. Only those devices, which conform to the listed parameters may be connected to driver. If the array is empty, system tries to connect each device to the driver.
Field driver indicates, that usb_driver is derived from device_driver.
In the most simple case each element of id_table[i] contains few identifiers:

* identifier of manufacturer (Vendor ID)
* identifier of the device (Device ID).

Definition of the structure usb_device_id may be seen in
include/linux/mod_devicetable.h

probe and disconnect; these are callback-functions, fetched by system while connecting and disconnecting of the USB-device. probe will be fetched for each device, if the list id_table is empty, or only for those, which correspond to the listed parameters.

Example.

#include

#define MY_DEV_NAME “my_usb_device”
#define PRODUCT_ID 0×1
#define VENDOR_ID 0×1234

static struct usb_device_id my_table [] = {
{ USB_DEVICE(VENDOR_ID, PRODUCT_ID) },
{ } // terming list element
};

static struct usb_driver my_driver = {
.name = MY_DEV_NAME,
.probe = my_probe,
.disconnect = my_disconnect,
.id_table = my_table,
};

static int __init my_module_init(void)
{
// registering driver
return usb_register(&my_driver);
}

static void __exit my_module_exit(void)
{
// unloading driver
usb_deregister(&my_driver);
}

In this example the driver of USB-device, which has fields’ meanings
PRODUCT_ID = 0×1, VENDOR_ID = 0×1234 is registered. Function my_probe will be fetched only for device with such parameters.

Fetching my_probe in fact means registration of the device in driver
my_driver, and fetching my_disconnect means removal of device. So let’s pass on the next stage – registration\removal of the device.

Registration of the device.

One registered driver is able to “connect” few devices. For connecting device to the driver system fetches driver’s function probe, which transfers 2 parameters:

static int my_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
// …
}

interface is the interface of the USB-device. Usually USB-driver
interacts directly not with the device, but with its interface. id -
contains information about the device. If the function retrieves 0, this means that device is registered successfully, otherwise system tries to “attach” device to any other driver.
To disconnect device from the driver system fetches function
disconnect, to which the only parameter is send – interface:

static void my_disconnect(struct usb_interface *interface)
{
// …
}

In generic case, the structure in memory for each connecting device is allocated in function probe, it is filled and then registered, e.g. symbolic device, and the registration of the device in sysfs is carried out. Also verification for the necessary EP could be carried out in function probe.

As an example of registration\removal of the device you’d better apply to example from the linux core, which is located in drivers/usb/usb-skeleton.c.

Usage of USB Major

Let’s examine the registration of symbolic device in details. As it is already known, for the registration of symbolic device we need to receive number major, whether statically (apply to maintainer of the core and insert it into include/linux/major.h), or dinamically (fetching
register_chrdev with parameter major = 0). When symbolic device is registered, it is necessary to create file in directory /dev. For this purpose we may use whether command mknod (from user-space) or
functions devfs, if this core supports devfs.

In the core version 2.6 the operation described above is much simplified due to appearing of udev and sysfs. Program-daemon udevd is working in the system, which tracks appearance of files in sysfs (/sys/class/). On the basis of information read from these files, it creates necessary files automatically in dev, using the rules udev for the current device.
For these purposes there is function usb_register_dev in programming interface of USB. It processes all the necessary for udev to conduct the listed above operations:

extern int usb_register_dev(struct usb_interface *intf,
struct usb_class_driver *class_driver);
extern void usb_deregister_dev(struct usb_interface *intf,
struct usb_class_driver *class_driver);

usb_register_dev excepts for input interface è class_driver. Structure
usb_class_driver looks as follows:

struct usb_class_driver {
char *name;
struct file_operations *fops;
int minor_base;
};

name - is the name of the device. Direcory with this name will appear in sysfs.
fops - file operations of the symbolic device. minor_base - basic
minor number.

Function usb_register_dev carries out the following actions:

* registeres symbolic device with major number 180 (include/linux/major.h) and backups the range from 16 minor numbers
That’s why minor_base needs to have junior half-byte = 0.

* points out one number for the current device from the backuped range of minor numbers. This number is written in â interface->minor.

* creates all the necessary files in sysfs: after this udev creates files in /dev/

Fetching of usb_deregister_dev carries out opposite options, that is why it has to be fetched in function disconnect.

Data exchange with the device

Let us examine data exchange for the most frequently used types:
control and bulk. Corresponding functions are defined in
drivers/usb/core/message.c.

Control transfer

For the sending\receiving of the data in zero EP function
usb_control_msg is used:

extern int usb_control_msg(struct usb_device *dev, unsigned int pipe,
__u8 request, __u8 requesttype, __u16 value, __u16 index,
void *data, __u16 size, int timeout);

dev - reference to usb_device. This indicator can be received by fetching of the function interface_to_usbdev(interface). pipe - EP pipe.
This parameters contains: type of data transfer(bulk, control, …),
direction, number EP. For specifying pipe in include/linux/usb.h
macros are defined. Below are few of them:

#define usb_sndctrlpipe(dev,endpoint) \
((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint))
#define usb_rcvctrlpipe(dev,endpoint) \
((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)

#define usb_sndbulkpipe(dev,endpoint) \
((PIPE_BULK << 30) | __create_pipe(dev,endpoint))
#define usb_rcvbulkpipe(dev,endpoint) \
((PIPE_BULK << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)

Parameters request, request_type, value, index are the fields setup-packet.
Their contents depends on application. data, size are the array for sending\receiving. Look above [2,3].

timeout is parameter, specifying how much time is given for sending\receiving.

It is necessary to keep in mind that function usb_control_msg retrieves the value only after setup-packet and data are delivered or if a mistake of time-out take place. This function uses fetching interruptible_sleep_on, that is why this function shouldn’t be used in breakup.

Example. Sending of setup-packet with specified bRequest and wValue can look ad follows:

// …
int ret;
struct usb_device* udev = interface_to_usbdev(interface);

ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
bRequest, USB_TYPE_VENDOR,
wValue, 0, udev, 0, HZ);
// …

In this example only setup-package is sent. That is why data = udev,
size = 0.

Bulk transfer

For usage of bulk transfer function usb_bulk_msg is used:

extern int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
void *data, int size, int *actual_size,
int timeout);

Attributes dev, pipe, data, size, timeout have the same meaning as in
usb_control_msg. actual_size - quantity of actually transferred data. actual_size <= size.

usb_bulk_msg has the same attribute with usb_control_msg – it cannot be fetched if breakup.

Example. Accepting of 100 byte from 5th EP can look as follows:

// …
struct usb_device* udev = interface_to_usbdev(interface);
u8 buf[[ ;]]
int ret, actual_size;
ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 5), buf, 100, &actual_size, HZ)
;
// …

Conclusion

USB specification defines large quantity of data transfer types, packets, algorithms. All the USB algorithms are instantiated in linux core. Convenient and simple interface is represented to drivers programmer in terms of set of functions, macros, structures. In linux core 2.6 subsystem of USB is fit well into the model UDM[3,4], this makes it flexible for interaction with udev, sysfs.

Web Design-isms: 7 Surefire Styles that Work

Glossy buttons, ornamental backgrounds, futuristic interfaces. We ’ve all been guilty at one time or another of committing the 7 design-isms in this article from Larissa Meek. But that’s okay, she tells us, they’re classics for a reason.
Visit: Web Design-isms: 7 Surefire Styles that Work

CSS Galleries: Free Web Designs for Download

A list of free CSS HTML Web design download resources including brief descriptions and screenshots of the repective sites. Includes generic and special resources for content management, forum, and blogging systems like e107, Drupal, Joomla, Mambo, PHP-Fusion, phpBB, PHPNuke, vBulletin, Wordpress, and Xoops.
Visit: CSS Galleries: Free Web Designs for Download

Best MySpace Layouts That Don’t Look Like MySpace At All

There’s an underground trend that ’s been going on for quite some time among those who don’t enjoy the usual MySpace layout aesthetic - loud music, tons of animations, layout that’s falling apart and color matching from hell. These folks have gone to great lengths to make their MySpace profiles as different from the “standard” MySpace layout as poss
Visit: Best MySpace Layouts That Don’t Look Like MySpace At All

2008 May Be the Year of the Open-Source Desktop

Over the past year, I ’ve been on a quest to find an operating system that balances ease of use, stability, low cost and high functionality. My experiences were the subject of an article in CIO magazine that described how I tried to use my enterprise applications with Windows XP, Mac OS X, Red Hat and Fedora.
Visit: 2008 May Be the Year of the Open-Source Desktop

Anatomy of the Linux Kernel

The Linux kernel is the core of a large and complex operating system, and while it’s huge, it is well organized in terms of subsystems and layers. In this article, you explore the general structure of the Linux kernel and get to know its major subsystems and core interfaces.
Visit: Anatomy of the Linux Kernel

Mythbuntu 7.04 Public Alpha 1

After lots of hard work the past month, the Mythbuntu team is proud to present our first publicly announced Alpha. This alpha can be used for running a live frontend from CD, and provides a good representation of where the GUI is headed for the installer. The CD contains a backend/frontend full installation on disk with all plugins.
Visit: Mythbuntu 7.04 Public Alpha 1

A Dell/Ubuntu Laptop - Right out of the box

The day Dell announced I ordered one of their laptops, and today (May 31) it arrived. I popped open the box to see what’s included. The only Ubuntu-specific thing included was the CD. I half-expected to see the ‘DELL’ logo on the blue-shirted guy.
Visit: A Dell/Ubuntu Laptop - Right out of the box

Top Ten of Programming Advice NOT to Follow

A top programmer examines a number of the top items of programming advice commonly given, and makes a great case for why they should NOT be followed. Some interesting food for thought for any programmer.
Visit: Top Ten of Programming Advice NOT to Follow

Essential HTML, CSS, Javascript, PHP etc., via Marc Andreessen

There are a ton of free cheatsheets, quick references, and downloadable resources for programming languages and related technologies online — in this post I’ve tried to organize and list some of the best for web development.
Visit: Essential HTML, CSS, Javascript, PHP etc., via Marc Andreessen

CSS layouts “for those who want to start a css-driven website quick”

I placed a comment with a link to CSSeasy.com in another story and you’re all digging it up so I thought it would be good to write a story about this simple site for people who want to start a css-driven website quick or for those people who want to start learning CSS by trial and error.
Visit: CSS layouts “for those who want to start a css-driven website quick”

10 Things to Know When Starting A Facebook Application

By releasing a development platform, Facebook’s enabled developers to create some amazing applications riding off their social network. It’s not too hard to get an application of your own up and running, but it’s nice to have some help, as the documentation’s not complete. Here are a few tips to help you get started!
Visit: 10 Things to Know When Starting A Facebook Application

Let’s Build a Grid - Webdesign

So much web design work relies on establishing a grid and the constraints on that grid: ad sizes, display size, browser display area minus chrome, and so forth. Grids are, quite literally, everywhere. But learning how to effectively utilize grids– without becoming a slave to them– can make the difference between a competent layout and a great layout.
Visit: Let’s Build a Grid - Webdesign

1. US computer and video game software sales grew six percent in 2006 to $7.4 billion – almost tripling industry software sales since 1996.

2. Sixty-nine percent of American heads of households play computer and video games.

3. The average game player is 33 years old and has been playing games for 12 years.

4. The average age of the most frequent game buyer is 40 years old. In 2006, 93 percent of computer game buyers and 83 percent of console game buyers were over the age of 18.

5. Eighty-five percent of all games sold in 2005 were rated “E” for Everyone, “T” for Teen, or “E10+” for Everyone 10+. For more information on ratings, please see www.esrb.org.

6. Eighty-seven percent of game players under the age of 18 report that they get their parents’ permission when renting or buying games, and 89 percent say their parents are present when they buy games.

7. Thirty-five percent of American parents say they play computer and video games. Further, 80 percent of gamer parents say they play video games with their kids. Sixty-six percent feel that playing games has brought their families closer together.

8. Thirty-eight percent of all game players are women. In fact, women over the age of 18 represent a significantly greater portion of the game-playing population (30%) than boys age 17 or younger (23%).

9. In 2005, 25 percent of Americans over the age of 50 played video games, an increase from nine percent in 1999.

10. Forty-four percent of game players say they play games online one or more hours per week. In addition, 32 percent of heads of households play games on a wireless device, such as a cell phone or PDA, up from 20 percent in 2002.

If any of you believes that Google and Yahoo are just two simple companies that are challenging one another with their products, I’m sorry to tell you that you’re wrong. Google and Yahoo are currently the Internet
giants that are offering the best technologies in their categories but also manage to attract the majority of
customers, making the other firms’ attempts quite useless. Take the example of Ask.com that is somehow made anonymous as Google and Yahoo captured most of the Internet searches. However, a lot of companies announced their intentions to develop similar products and challenge the two Goliaths.

At this time, the most important chapter of the battle is surely represented by the fight between the two mail solutions owned by the companies. Most of the users are describing Gmail as the most efficient mail product on the Internet because it offers a large file storage capacity, efficient spam filters and POP3 support. The same category of users is often criticizing Yahoo Mail for weak filters, bugs and for instability. However, the recent studies revealed that Yahoo Mail managed to beat Gmail, the Google mail product not being even close to the Sunnyvale company’s solution. Hotmail, one of the oldest mail services on the Internet earned the second position, relegating Gmail right on the third place.

However, the most recent battle involves two unexpected products: Google Maps and Yahoo Maps. While the search giant is famous for its service and the high-resolution photos that it offers, Yahoo intends to make its map solution competitive for Google. Recently, Yahoo added a considerable number of detailed pictures for numerous European countries.

You’re probably asking yourself what’s up with the title. Well, Google and Yahoo managed to revolutionize the Internet life because their solutions – the search engine and the Yahoo portal – are currently helping people find their information easier and get whatever they want.

It can be frustrating to find out that the photos you’re trying to share, or the presentations you’re trying to send at the last minute, are too large for your email’s attachment limit. Some of you have pointed out that we recently increased the allowable attachment size in Gmail from 10MB to 20MB. We think the higher limit will help make the storage in your Gmail account a little more useful. So the next time you’ve got to send a PDF that’s a bit on the larger side, relax. You’ve got some more room to spare.

Source: http://googleblog.blogspot.com/2007/05/bigger-attachments-in-gmail.html, Posted by Anna-Christina Douglas