f all goes as anticipated (and it never does), Windows 7 will arrive in 2010. Therefore, if you’ve done the math that means Windows XP, originally released in 2001, will be nine years old. A nine-year-old operating system is human equivalent of a centenarian.

As we know this is no easy feat it calls for some serious life extension techniques.

I think this is a fitting analogy actually, since running Windows XP for another 1-2 years is a very real possibility for some. After all, many who despised Vista will likely not only wait for Windows 7 to release. They will most likely wait for the first service pack to arrive before making a change. That would put us possibly into 2011.

So if you want to see Windows XP make it to the ripe old age of ten, you should likewise take steps to keep it in good health.

* Email Article
* Print Article
*
Share Articles
o Digg
o del.icio.us
o Newsvine

1) Run Windows Updates

As an IT Director, I cannot recall how many times I had someone bring me a PC with XP installed on it from home and tell me it does not work right. Nine times out of ten, the Windows updates were not done.

In a few cases, they had not even installed SP2. When XP was released, many of the technologies we have available today were in their infancy or non-existent. Keeping Windows updated will help keep you running well.

2) Add Memory and Move Data Online or to an External Drive
It is no secret Windows runs better with more memory, so maximize XP by adding RAM.

Another essential fact: Windows runs better if you have at least 20 percent disk space available. With the advent of downloadable Music and Movies (legally of course), you need to beware. Both RAM and storage are cheap these days so why not invest in some to keep your system in an optimal state. At a mere 38 years old (in human years) I wish I could just simply add some extra memory or possibly off-load some things to external memory. Perhaps they will have that available by 2010 as well…

3) Run System & Driver Updates

Another area that even many IT people are guilty of, is not updating the system itself. BIOS updates and driver updates go a long way to help keep things running smoothly.

It is important to remember, though, with driver updates, never run the “beta driver.” It is also a good idea to backup your system, in case the driver causes something to stop working.

Now it bears saying that if it’s not broke, don’t fix it, likewise you may be living with some issues. If you fit this description you need to decide if you’re happy with the issue from the driver. In that case perhaps you can live with it for a while longer.

4) Do Not Keep Up with the Joneses

The latest and greatest is always the smartest and efficient. Many of the software packages created today are built for the Vista platform or beyond. New software is always coded new systems and vice-versa.

So you need to decide if the latest version of Office or the newest Adobe Acrobat release is really necessary. If you can live without it (and be honest with yourself) than run the older version. Both you and XP will be happier.

If you've been working with databases for a while, chances are you've heard the term normalization. Perhaps someone's asked you "Is that database normalized?" or "Is that in BCNF?" All too often, the reply is "Uh, yeah." Normalization is often brushed aside as a luxury that only academics have time for. However, knowing the principles of normalization and applying them to your daily database design tasks really isn't all that complicated and it could drastically improve the performance of your DBMS.

In this article, we'll introduce the concept of normalization and take a brief look at the most common normal forms. Future articles will provide in-depth explorations of the normalization process.
What is Normalization?
Normalization is the process of efficiently organizing data in a database. There are two goals of the normalization process: eliminating redundant data (for example, storing the same data in more than one table) and ensuring data dependencies make sense (only storing related data in a table). Both of these are worthy goals as they reduce the amount of space a database consumes and ensure that data is logically stored.
The Normal Forms
The database community has developed a series of guidelines for ensuring that databases are normalized. These are referred to as normal forms and are numbered from one (the lowest form of normalization, referred to as first normal form or 1NF) through five (fifth normal form or 5NF). In practical applications, you'll often see 1NF, 2NF, and 3NF along with the occasional 4NF. Fifth normal form is very rarely seen and won't be discussed in this article.

Before we begin our discussion of the normal forms, it's important to point out that they are guidelines and guidelines only. Occasionally, it becomes necessary to stray from them to meet practical business requirements. However, when variations take place, it's extremely important to evaluate any possible ramifications they could have on your system and account for possible inconsistencies. That said, let's explore the normal forms.
First Normal Form (1NF)
First normal form (1NF) sets the very basic rules for an organized database:

* Eliminate duplicative columns from the same table.
* Create separate tables for each group of related data and identify each row with a unique column or set of columns (the primary key).

Second Normal Form (2NF)
Second normal form (2NF) further addresses the concept of removing duplicative data:

* Meet all the requirements of the first normal form.
* Remove subsets of data that apply to multiple rows of a table and place them in separate tables.
* Create relationships between these new tables and their predecessors through the use of foreign keys.

Third Normal Form (3NF)
Third normal form (3NF) goes one large step further:

* Meet all the requirements of the second normal form.
* Remove columns that are not dependent upon the primary key.

Fourth Normal Form (4NF)
Finally, fourth normal form (4NF) has one additional requirement:

* Meet all the requirements of the third normal form.
* A relation is in 4NF if it has no multi-valued dependencies.

Remember, these normalization guidelines are cumulative. For a database to be in 2NF, it must first fulfill all the criteria of a 1NF database.

If you'd like to ensure your database is normalized, explore our other articles in this series:

* Database Normalization Basics
* Putting your Database in First Normal Form
* Putting your Database in Second Normal Form
* Putting your Database in Third Normal Form

If you want to receive notifications of new database articles posted on this site, Subscribe to our newsletter
By Mike Chapple, About.com

Remember to seek out, change and manage every password in your IT infrastructure, or you'll fail your PCI audit.
While corporations are struggling with PCI compliance after PCI 6.6 became mandatory June 30, they may be overlooking one of the most critical areas for compliance -- passwords.

Generally, enterprises do not revoke passwords when their owners move to other departments within the company or leave, resulting in orphaned accounts.

But user and system administrator passwords are just the tip of the iceberg -- literally thousands of other passwords are hidden from view, such as application-to-application passwords, passwords embedded in applications and the passwords every device on a corporate network comes with.

The last category includes laptops, desktops, appliances, routers, bridges and just any other device you can think of.
"If you don't change the default passwords applications and devices are shipped with, you could fail your PCI audit, because these are freely available online," Robert Grapes, chief technologist of Cloakware's data center solutions, told InternetNews.com.
"There's more than 3,000 vendors and products listed with the default passwords on the Internet; very few people go through their devices or operating systems and change the passwords," he added.

Identities and passwords that have been hard-coded into applications or servers are the most difficult to revoke or change, and are often ignored because of this.

"I talked to one company who had not changed passwords on particular systems of theirs for 17 years," Grapes said.
Passwords on applications and devices, and administrator passwords, are privileged accounts, meaning they have more permissions and rights than the average end user. Such accounts constitute one of the biggest potentials for enterprise security breaches.

"There are many times the number of privileged accounts operating on your network than there are end user accounts," Grapes said.


For example, in an enterprise with, say, 1,000 end users running on Windows, every laptop, desktop and server will have a local administrator account and service accounts that are not being managed, according to Grapes.

Then there are all the back-end applications running on other systems, such as Unix servers, blades and mainframes, the network management systems, the database accounts, each of which will have multiple privileged accounts.

The proliferation of privileged accounts is so great that "we recently completed a transaction with a large European bank with 80,000 employees, and they bought a contract for 525,000 accounts," Grapes said.

It's impossible to root out all the passwords and change them individually to comply with the PCI regulations, and Grapes said automation is the best solution.

The PCI regulations' password requirements proved a "major, major pain" for the large U.S. retail chain where Joey Peloquin used to work.

"We had more than 160,000 users, and automation was the only way we could solve the problem," Peloquin, now a senior security consultant in HP software professional services' application security division, told InternetNews.com.

His former employer selected a product from Cyber-Ark called the Enterprise Password Vault; Cloakware also offers a solution, called the Cloakware Server Password Manager.

Some enterprises let systems administrators share identities and passwords to contain password sprawl, but that generates problems of its own.

"If you have 10 administrators sharing a password and ID, how can you audit and trace who performed a particular function on that system?" Grapes asked.

Such tracking information is crucial to passing an audit.

The cost of failure can be high. When Peloquin's former employer failed a PCI audit, "we lost millions of dollars on the day we failed just through the increased commissions we had to pay," he said.

In the months following publication of the final part of the very popular series on integrating Google Maps into PHP applications, I've spent quite a bit of time working with another popular Web technology: Ruby on Rails. As it turns out, Rails developers have been hard at work creating a few amazing plugins capable of adding powerful mapping capabilities to your applications. In this new series, I'll introduce you to these powerful plugins, showing you a number of tips and tricks along the way.
I'll presume you're familiar with mapping fundamentals, including the basic ideas surrounding the Google mapping API syntax. If you haven't had the opportunity to experiment with the API, take some time to read this tutorial before continuing.
Introducing the YM4R/GM Plugin
Although there's nothing preventing you from linking to Google's mapping JavaScript API and referencing the library directly from your views, jumping between Ruby/Rails syntax and JavaScript can quickly become a tedious affair. The YM4R/GM plugin remedies this issue nicely, abstracting the API calls through Ruby's familiar object-oriented syntax. With it you can do everything from render simple maps to build complex maps complete with custom markers, information windows, and clusters for facilitating the rendering of large numbers of markers.
Installing and Configuring YM4R/GM
To install the YM4R/GM plugin, execute the following command from your project directory:%>ruby script/plugin install
svn://rubyforge.org/var/svn/ym4r/Plugins/GM/trunk/ym4r_gm
YM4R/GM manages the Google API keys within a file named gmaps_api_key.yml, found in the project's config directory. The developers save you the trouble of having to create your own API key for local testing purposes by including an API key that has already been tied to http://localhost:3000. However, if you're testing on a different host, you'll first need to create an API key and add it to this file (instructions for creating a key are provided in the aforementioned introductory tutorial).
Creating Your First Map

Figure 1: Centering the map over Youngstown, Ohio
As is standard Rails practice, you'll use the controller method to define the map and its features, and the view to render the results. In the following example, you'll define a map in the index controller's index action, complete with a pan/zoom control but minus the map type selector:def index
# Create a new map object, also defining the div ("map")
# where the map will be rendered in the view
@map = GMap.new("map")
# Use the larger pan/zoom control but disable the map type
# selector
@map.control_init(:large_map => true,:map_type => false)
# Center the map on specific coordinates and focus in fairly
# closely
@map.center_zoom_init([41.023849,-80.682053], 10)
end
Next, in the index action's corresponding view, add the following code:


<%= GMap.header %>
<%= @map.to_html %>


<%= @map.div(:width => 400, :height => 300) %>


The GMap.header call will output references to both the Google Maps API and YM4R/GM JavaScript libraries. The @map.to_html call outputs JavaScript code generated by YM4R/GM according to the specifications set forth in the action. Finally, the @map.div call outputs the map to a div as specified in the action's GMap.new call.
Also, you'll see that the map dimensions are defined in the view rather than the controller. This is keeping with the convention of separating application logic and design; the view designer can choose any dimension he pleases; the map will simply fill to the desired size. The initial zoom level is, however, defined in the controller, although the user can easily subsequently adjust the zoom using the control.

By : Jason Gilmore

Did you know that you can move sections of your Web.config file into other files? Whether it's to keep things tidy or simply to make it easier to find the settings you change often, it's easy to do and yet few people even realize you can.
The magic that makes this possible is the configSource attribute. It was added in .NET 2.0 and its value indicates the name of the file that contains the section that we're moving to another file. It's probably easiest to illustrate via a simple example. A normal connectionStrings section in Web.config might look something like this:
... ...
To move that section to a separate file, simply replace the connectionStrings section in the listing above with this line:

and then create a new "ConnectionStrings.config" file to hold the connectionStrings section's settings:

See... it really couldn't be much simpler. Now you can play with your connection strings as much as you want without fear of messing up any other settings in your Web.config file.
Oh... and just because I only showed you how to move the connectionStrings section, don't think that it stops there. You can just as easily move any section you want to an external file: appSettings, mailSettings, urlMappings, etc.
Source:ASP101