Server Administrator: Job Description and Education Requirements

The System Administrator (SA) is responsible for effective provisioning, installation/configuration, operation, and maintenance of systems hardware and software and related infrastructure. This individual participates in technical research and development to enable continuing innovation within the infrastructure. This individual ensures that system hardware, operating systems, software systems, and related procedures adhere to organizational values, enabling staff, volunteers, and Partners.

This individual will assist project teams with technical issues in the Initiation and Planning phases of our standard Project Management Methodology. These activities include the definition of needs, benefits, and technical strategy; research & development within the project life-cycle; technical analysis and design; and support of operations staff in executing, testing and rolling-out the solutions. Participation on projects is focused on smoothing the transition of projects from development staff to production staff by performing operations activities within the project life-cycle.

This individual is accountable for the following systems: Linux and Windows systems that support GIS infrastructure; Linux, Windows and Application systems that support Asset Management; Responsibilities on these systems include SA engineering and provisioning, operations and support, maintenance and research and development to ensure continual innovation.

SA Engineering and Provisioning

  1. Engineering of SA-related solutions for various project and operational needs.
  2. Install new / rebuild existing servers and configure hardware, peripherals, services, settings, directories, storage, etc. in accordance with standards and project/operational requirements.
  3. Install and configure systems such as supports GIS infrastructure applications or Asset Management applications.
  4. Develop and maintain installation and configuration procedures.
  5. Contribute to and maintain system standards.
  6. Research and recommend innovative, and where possible automated approaches for system administration tasks. Identify approaches that leverage our resources and provide economies of scale.

Operations and Support

  1. Perform daily system monitoring, verifying the integrity and availability of all hardware, server resources, systems and key processes, reviewing system and application logs, and verifying completion of scheduled jobs such as backups.
  2. Perform regular security monitoring to identify any possible intrusions.
  3. Perform daily backup operations, ensuring all required file systems and system data are successfully backed up to the appropriate media, recovery tapes or disks are created, and media is recycled and sent off site as necessary.
  4. Perform regular file archival and purge as necessary.
  5. Create, change, and delete user accounts per request.
  6. Provide Tier III/other support per request from various constituencies. Investigate and troubleshoot issues.
  7. Repair and recover from hardware or software failures. Coordinate and communicate with impacted constituencies.

Maintenance

  1. Apply OS patches and upgrades on a regular basis, and upgrade administrative tools and utilities. Configure / add new services as necessary.
  2. Upgrade and configure system software that supports GIS infrastructure applications or Asset Management applications per project or operational needs.
  3. Maintain operational, configuration, or other procedures.
  4. Perform periodic performance reporting to support capacity planning.
  5. Perform ongoing performance tuning, hardware upgrades, and resource optimization as required. Configure CPU, memory, and disk partitions as required.
  6. Maintain data center environmental and monitoring equipment.

KNOWLEDGE/SKILLS:

  1. Bachelor (4-year) degree, with a technical major, such as engineering or computer science.
  2. Systems Administration/System Engineer certification in Unix and Microsoft.
  3. Four to six years system administration experience.

COMPLEXITY/PROBLEM SOLVING:

  1. Position deals with a variety of problems and sometime has to decide which answer is best. The question/issues are typically clear and requires determination of which answer (from a few choices) is the best.

DISCRETION/LATITUDE/DECISION-MAKING:

  1. Decisions normally have a noticeable effect department-wide and company-wide, and judgment errors can typically require one to two weeks to correct or reverse.

RESPONSIBILITY/OVERSIGHT –FINANCIAL & SUPERVISORY:

  1. Functions as a lead worker doing the work similar to those in the work unit; responsibility for training, instruction, setting the work pace, and possibly evaluating performance.
  2. No budget responsibility.

COMMUNICATIONS/INTERPERSONAL CONTACTS:

  1. Interpret and/or discuss information with others, which involves terminology or concepts not familiar to many people; regularly provide advice and recommend actions involving rather complex issues. May resolve problems within established practices.
  2. Provides occasional guidance, some of which is technical.

WORKING CONDITIONS/PHYSICAL EFFORT:

  1. Responsibilities sometimes require working evenings and weekends, sometimes with little advanced notice.
  2. No regular travel required

For Careers in System Administration Apply Here

 

Source

A Guide to Using CSS Variables

Web designers accustomed to using CSS preprocessors are no strangers to CSS variables, but for those of us who are not, CSS variables are now officially part of the CSS specification. CSS variables, or more accurately, as they are called in the spec, CSS custom properties, can be useful for reducing repetition as well as for achieving runtime effects like theme switching. In this tutorial, we’ll be learning how to use CSS custom properties in our web pages.

Declaring and Using CSS Variables

Variables should be declared within a CSS selector that defines its scope. For a global scope you can use the :root or body selector. The variable name must begin with two dashes (–) and is case sensitive, so “–main-color” and “–Main-Color” would define two different custom properties. Other than these two hard rules, the allowed syntax for custom properties is actually quite permissive. Nevertheless, you would be well advised to follow the standard language naming convention of CSS: use dashes to separate the words in the property name.

The following CSS rule declares a custom property of global scope named “–main-color”, It has a value of “#06c”:

?
1
2
3
:root {
  --main-color: #06c;
}

To reference the variable, use the var() function. It retrieves the custom property value, so that it may be assigned to the property (#06c in this case). So long as the custom property is defined somewhere in your stylesheet and has a scope that includes the target element(s), it should be available to the var function.

?
1
2
3
#header h1 {
  color: var(--main-color);
}

Variables and Cascade Rules

Custom properties cascade much in the same way as rules, so you can define the same property at different levels of specificity:

?
1
2
3
4
5
6
/* default color */
:root { --color: blue; }
div { --color: green; }
.myclass { --color: red; }
/* applies the --color property at all the above levels */
* { color: var(--color); }

Here is some HTML markup that shows the effects of the above rules:

?
1
2
3
4
5
6
<p>I inherited blue from the root element!</p>
<div>I got green set directly on me!</div>
<div class="myclass">
  While I got red set directly on me!
  <p>I'm red too, because of inheritance!</p>
</div>

…which is displayed as:

I inherited blue from the root element!

I got green set directly on me!

While I got red set directly on me!I’m red too, because of inheritance!

More on the var() Function

We’ve already seen how to use the var() function to retrieve the value of a custom property. What I haven’t mentioned is that the val() function accepts a variable number of parameters: fallback values to be used when the referenced custom property is invalid. Fallback values can be a comma separated list, which will be combined into a single value by the function. For example var(--font-stack, "Helvetica Neue", "Helvetica", "Arial", "sans-serif"); defines a fallback of “Helvetica Neue, Helvetica, Arial, sans-serif” once combined.

Shorthand values may also be stored in a variable. Just like regular CSS, properties such as margin and padding are not comma separated, so an appropriate fallback for padding would define them the same way:

?
1
2
3
4
5
6
7
8
/* definition */
div {
  --color: green;
  --pad: 10px 10px 20px 15px;
}
/* usage */
p { padding: var(--pad, 10px 10px 10px) };

The browser inspector confirms that the variable was successfully applied:

css_variables_shorthand_value_in_action.jpg

Combining var() with the call() Function

Very recently, I wrote about the CSS3 calc() function. It, like other CSS3 functions, may include variables in its expression. So, let’s say that you wanted to apply a size factor to the font. You can’t just append the measurement unit to the variable:

?
1
2
3
4
5
/* definition */
:root { --font-size-factor: 2.5; }
/* faulty application - WON'T WORK! */
div > p { font-size: var(--font-size-factor)em; }

However, if we multiply the –font-size-factor by one unit of measurement, we get a valid and usable result:

?
1
2
3
4
5
6
7
/* definition */
:root { --font-size-factor: 2.5; }
/* valid application! */
div > p {
  font-size: calc(var(--font-size-factor) * 1em);
}

Accessing Custom Properties in JavaScript

Thanks to the window.getComputedStyle() function, it’s not only easier than ever to access CSS properties from your JavaScript code, but it also works for variables! Here’s some code that fetches the –color property value of a DIV and displays it. Moreover, the CSS property value is reused to set the color of the property value to the very color that it describes!

?
1
2
3
4
5
var elem       = document.getElementById("alert"),
    theCSSprop = window.getComputedStyle(elem, null).getPropertyValue("--color").trim(),
    msgElt     = document.getElementById("computed_style");
msgElt.innerHTML = "The alert div's color is \"<span style='color:" + theCSSprop + "'>" + theCSSprop +'</span>".';

…which would output something along the lines of:

The alert div’s color is “red”.

You can also set the value of an existing one at runtime, using the setProperty() method of the CSSStyleDeclaration object. Here’s some code that calls the function from a button click:

?
1
2
3
4
5
6
7
//HTML
<p><button id="change_doc_color" onclick="changeDocColor()">Change document color to green</button></p>
//JS
function changeDocColor() {
    elem.style.setProperty('--color', 'green');
}

Since setProperty() will accept any valid CSS code, the value string may include the var() function as well. That would allow us to predefine our color before using it, in order to perhaps reuse it elsewhere.

?
1
2
3
4
5
6
7
//CSS
:root { --color: blue; --new-color: green; }
//JS
function changeDocColor() {
    elem.style.setProperty('--color', 'var(--new-color)');
}

Conclusion

A word of caution, not all browsers support CSS variables at this time. Most notably, Internet Explorer, Opera Mini, and the Android browser don’t recognize them.

Want to try any of today’s examples? they’re all up on CodePen.


Rob Gravelle

Rob Gravelle resides in Ottawa, Canada, and is the founder of GravelleWebDesign.com. Rob has built systems for Intelligence-related organizations such as Canada Border Services, CSIS as well as for numerous commercial businesses.

In his spare time, Rob has become an accomplished guitar player, and has released several CDs. His band, Ivory Knight, was rated as one of Canada’s top hard rock and metal groups by Brave Words magazine (issue #92) and reached the #1 spot in the National Heavy Metal charts on Reverb Natio

Source: HTML Goodies

CSS – Syntax

A CSS comprises of style rules that are interpreted by the browser and then applied to the corresponding elements in your document. A style rule is made of three parts −

  • Selector − A selector is an HTML tag at which a style will be applied. This could be any tag like <h1> or <table> etc.
  • Property – A property is a type of attribute of HTML tag. Put simply, all the HTML attributes are converted into CSS properties. They could be color, border etc.
  • Value – Values are assigned to properties. For example, color property can have value either red or #F1F1F1 etc.

You can put CSS Style Rule Syntax as follows −

selector { property: value }

Syntax

Example: You can define a table border as follows −

table{ border :1px solid #C00; }

Here table is a selector and border is a property and given value 1px solid #C00 is the value of that property.

You can define selectors in various simple ways based on your comfort. Let me put these selectors one by one.

The Type Selectors

This is the same selector we have seen above. Again, one more example to give a color to all level 1 headings:

h1 {
   color: #36CFFF; 
}

The Universal Selectors

Rather than selecting elements of a specific type, the universal selector quite simply matches the name of any element type −

* { 
   color: #000000; 
}

This rule renders the content of every element in our document in black.

The Descendant Selectors

Suppose you want to apply a style rule to a particular element only when it lies inside a particular element. As given in the following example, style rule will apply to <em> element only when it lies inside <ul> tag.

ul em {
   color: #000000; 
}

The Class Selectors

You can define style rules based on the class attribute of the elements. All the elements having that class will be formatted according to the defined rule.

.black {
   color: #000000; 
}

This rule renders the content in black for every element with class attribute set to black in our document. You can make it a bit more particular. For example:

h1.black {
   color: #000000; 
}

This rule renders the content in black for only <h1> elements with class attribute set to black.

You can apply more than one class selectors to given element. Consider the following example:

<p class="center bold">
   This para will be styled by the classes center and bold.
</p>

The ID Selectors

You can define style rules based on the id attribute of the elements. All the elements having that id will be formatted according to the defined rule.

#black {
   color: #000000; 
}

This rule renders the content in black for every element with id attribute set toblack in our document. You can make it a bit more particular. For example −

h1#black {
   color: #000000; 
}

This rule renders the content in black for only <h1> elements with id attribute set to black.

The true power of id selectors is when they are used as the foundation for descendant selectors, For example:

#black h2 {
   color: #000000; 
}

In this example all level 2 headings will be displayed in black color when those headings will lie with in tags having id attribute set to black.

The Child Selectors

You have seen the descendant selectors. There is one more type of selector, which is very similar to descendants but have different functionality. Consider the following example −

body > p {
   color: #000000; 
}

This rule will render all the paragraphs in black if they are direct child of <body> element. Other paragraphs put inside other elements like <div> or <td> would not have any effect of this rule.

The Attribute Selectors

You can also apply styles to HTML elements with particular attributes. The style rule below will match all the input elements having a type attribute with a value of text

input[type = "text"]{
   color: #000000; 
}

The advantage to this method is that the <input type = “submit” /> element is unaffected, and the color applied only to the desired text fields.

There are following rules applied to attribute selector.

  • p[lang] – Selects all paragraph elements with a lang attribute.
  • p[lang=”fr”] – Selects all paragraph elements whose lang attribute has a value of exactly “fr”.
  • p[lang~=”fr”] – Selects all paragraph elements whose lang attribute contains the word “fr”.
  • p[lang|=”en”] – Selects all paragraph elements whose lang attribute contains values that are exactly “en”, or begin with “en-“.

Multiple Style Rules

You may need to define multiple style rules for a single element. You can define these rules to combine multiple properties and corresponding values into a single block as defined in the following example −

h1 {
   color: #36C;
   font-weight: normal;
   letter-spacing: .4em;
   margin-bottom: 1em;
   text-transform: lowercase;
}

Here all the property and value pairs are separated by a semi colon (;). You can keep them in a single line or multiple lines. For better readability we keep them into separate lines.

For a while, don’t bother about the properties mentioned in the above block. These properties will be explained in the coming chapters and you can find complete detail about properties in CSS References.

Grouping Selectors

You can apply a style to many selectors if you like. Just separate the selectors with a comma, as given in the following example −

h1, h2, h3 {
   color: #36C;
   font-weight: normal;
   letter-spacing: .4em;
   margin-bottom: 1em;
   text-transform: lowercase;
}

This define style rule will be applicable to h1, h2 and h3 element as well. The order of the list is irrelevant. All the elements in the selector will have the corresponding declarations applied to them.

Source: TutorialsPoint.Com

JavaScript – Syntax

javas

Javascript can be implemented using JavaScript statements that are placed within the <script>… </script> HTML tags in a web page.

You can place the <script> tags, containing your JavaScript, anywhere within you web page, but it is normally recommended that you should keep it within the <head> tags.

The <script> tag alerts the browser program to start interpreting all the text between these tags as a script. A simple syntax of your JavaScript will appear as follows.

<script ...>
   JavaScript code
</script>

The script tag takes two important attributes −

  • Language − This attribute specifies what scripting language you are using. Typically, its value will be javascript. Although recent versions of HTML (and XHTML, its successor) have phased out the use of this attribute.
  • Type − This attribute is what is now recommended to indicate the scripting language in use and its value should be set to “text/javascript”.

So your JavaScript segment will look like −

<script language="javascript" type="text/javascript">
   JavaScript code
</script>

Your First JavaScript Script

Let us take a sample example to print out “Hello World”. We added an optional HTML comment that surrounds our JavaScript code. This is to save our code from a browser that does not support JavaScript. The comment ends with a “//–>”. Here “//” signifies a comment in JavaScript, so we add that to prevent a browser from reading the end of the HTML comment as a piece of JavaScript code. Next, we call a function document.write which writes a string into our HTML document.

This function can be used to write text, HTML, or both. Take a look at the following code.

<html>
   <body>
      <script language="javascript" type="text/javascript">
         <!--
            document.write("Hello World!")
         //-->
      </script>
   </body>
</html>

This code will produce the following result −

Hello World!

Whitespace and Line Breaks

JavaScript ignores spaces, tabs, and newlines that appear in JavaScript programs. You can use spaces, tabs, and newlines freely in your program and you are free to format and indent your programs in a neat and consistent way that makes the code easy to read and understand.

Semicolons are Optional

Simple statements in JavaScript are generally followed by a semicolon character, just as they are in C, C++, and Java. JavaScript, however, allows you to omit this semicolon if each of your statements are placed on a separate line. For example, the following code could be written without semicolons.

<script language="javascript" type="text/javascript">
   <!--
      var1 = 10
      var2 = 20
   //-->
</script>

But when formatted in a single line as follows, you must use semicolons −

<script language="javascript" type="text/javascript">
   <!--
      var1 = 10; var2 = 20;
   //-->
</script>

Note − It is a good programming practice to use semicolons.

Case Sensitivity

JavaScript is a case-sensitive language. This means that the language keywords, variables, function names, and any other identifiers must always be typed with a consistent capitalization of letters.

So the identifiers Time and TIME will convey different meanings in JavaScript.

NOTE − Care should be taken while writing variable and function names in JavaScript.

Comments in JavaScript

JavaScript supports both C-style and C++-style comments, Thus −

  • Any text between a // and the end of a line is treated as a comment and is ignored by JavaScript.
  • Any text between the characters /* and */ is treated as a comment. This may span multiple lines.
  • JavaScript also recognizes the HTML comment opening sequence <!–. JavaScript treats this as a single-line comment, just as it does the // comment.
  • The HTML comment closing sequence –> is not recognized by JavaScript so it should be written as //–>.

Example

The following example shows how to use comments in JavaScript.

<script language="javascript" type="text/javascript">
   <!--
   
      // This is a comment. It is similar to comments in C++
   
      /*
      * This is a multiline comment in JavaScript
      * It is very similar to comments in C Programming
      */
   
   //-->
</script>

Source: Tutorialspoint.com

The Challenges Of A Web Developer

The biggest challenges is staying up to date in web development field.

To be a web developer we must be able to handle the langauge perfectly and that means staying always up to date. Let’s not forget that technology moves in giant paces and we have to be fit and agile in order to keep up with all the novelty.

So, one of the biggest challenges is staying up to date.

A web developer needs to be always searching and discovering new tools, content, apps and other upgrades that are not limited to changes in web developing language, but also expand to the technical, aesthetic, graphic, cultural and social aspects of web developing.

Offering an encompassing vision of technology and its many applications is another one of the challenges of a web developer.

It is essential to develop much more than your hand muscles by extensive typing. Web developers have to dip into the fields of mechanics, engineering and similar areas to build up a more flexible and powerful mind.

Basically, web developers need to invest in their web accessibility, hosting capacity, on-going professional improvement, technological equipment and entertainment.

There is no worse approach to web developing than allowing yourself to become stagnate by standing still and conforming. Curiosity, a spirit for research, agility, concentration, creativity and logic are a few of the recommended traits for anyone who wishes to propel the next generation of businesses developing their web platforms.

Web Careers Job Market

As ecommerce continues to grow, careers in web profession will grow along with it. This means that the opportunities for web designer jobs are expected to be plentiful. The projected increase should be around 20 percent over the next few years. In 2012 there were 141,400 web developer jobs, but that number should go up to as many as 169,900 by 2022.

Web Careers Salaries

People need professional-looking web sites, so they’ll pay nicely for your time to develop one for them. The BLS reports that the median yearly salary for web developers to be 40,000 to 100,00 depending on experience and talent, not too shabby for a job that lets you exercise your creativity and Internet know-how.

 

Web Developer Skills & Responsibilities

Typical day-to-day activities and marketable skill sets for web developers include the following. Web Developers:

  • Are fluent in the core web development scripting languages: HTML, CSS and Javascript.
  • Should know one or more server-side programming languages, such as Java, PHP and .Net.
  • Use search engine optimization (SEO) to develop websites that rank high in Google, Bing, etc.
  • Test web pages and web apps in multiple browsers, e.g., Chrome, FireFox & Internet Explorer.
  • Implement Cascading Style Sheets (CSS) to efficiently control the style of multiple pages in site.
  • Develop websites that interact with popular database systems like MySQL, SQL Server & Oracle.
  • Use wireframes to plan the layout, navigation and functionality of new web development projects.
  • Communicate with clients and colleagues to troubleshoot websites and optimize performance.
  • Some web developers are responsible for designing a website’s graphics and multimedia elements.

Prakash Jaydev Web Developer from Hyderabad

Redirections of some web pages

http://www.cnet.com/news/java-on-google-app-engine-not-yet/

http://www.cnet.com/uk/news/java-on-google-app-engine-not-yet/

http://japan.cnet.com/news/ent/20382573/

http://japan.zdnet.com/article/20382573/

http://builder.japan.zdnet.com/tool/20382573/

http://www.zdnet.fr/actualites/le-support-de-java-dans-google-app-engine-attendra-39384379.htm

http://dickwall.libsyn.com/webpage/2008/10

http://geektimes.ru/post/55947/

http://www.developerfusion.com/media/8345/java-posse-213-newscast-for-oct-23rd-2008/

http://abava.blogspot.ru/2008_10_01_archive.html

http://www.linux.org.ru/news/java/3185105

http://archives.javaposse.com/webpage/2008/10

http://www.javaposse.com/webpage/2008/10

http://archives.javaposse.com/webpage/year/2008/page/2/size/10

http://archives.javaposse.com/webpage/page/25/size/10

http://archives.javaposse.com/webpage/category/podcasts/page/12/size/10

http://archives.javaposse.com/webpage/year/2008/month/10/page/1/size/10

http://www.siliconindia.com/startupcity_09/blog.php

http://blog.richardadamdean.com/?p=9

http://blog.symbiont.net/2008_10_01_archive.html

 

 

SQL – RDBMS Concepts

RDBMS

What is RDBMS?

RDBMS stands for Relational Database Management System. RDBMS is the basis for SQL, and for all modern database systems like MS SQL Server, IBM DB2, Oracle, MySQL, and Microsoft Access.

A Relational database management system (RDBMS) is a database management system (DBMS) that is based on the relational model as introduced by E. F. Codd.

What is table?

The data in RDBMS is stored in database objects called tables. The table is a collection of related data entries and it consists of columns and rows.

Remember, a table is the most common and simplest form of data storage in a relational database. Following is the example of a CUSTOMERS table:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

What is field?

Every table is broken up into smaller entities called fields. The fields in the CUSTOMERS table consist of ID, NAME, AGE, ADDRESS and SALARY.

A field is a column in a table that is designed to maintain specific information about every record in the table.

What is record or row?

A record, also called a row of data, is each individual entry that exists in a table. For example there are 7 records in the above CUSTOMERS table. Following is a single row of data or record in the CUSTOMERS table:

+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

A record is a horizontal entity in a table.

What is column?

A column is a vertical entity in a table that contains all information associated with a specific field in a table.

For example, a column in the CUSTOMERS table is ADDRESS, which represents location description and would consist of the following:

+-----------+
| ADDRESS   |
+-----------+
| Ahmedabad |
| Delhi     |
| Kota      |
| Mumbai    |
| Bhopal    |
| MP        |
| Indore    |
+----+------+

What is NULL value?

A NULL value in a table is a value in a field that appears to be blank, which means a field with a NULL value is a field with no value.

It is very important to understand that a NULL value is different than a zero value or a field that contains spaces. A field with a NULL value is one that has been left blank during record creation.

SQL Constraints:

Constraints are the rules enforced on data columns on table. These are used to limit the type of data that can go into a table. This ensures the accuracy and reliability of the data in the database.

Constraints could be column level or table level. Column level constraints are applied only to one column where as table level constraints are applied to the whole table.

Following are commonly used constraints available in SQL:

  • NOT NULL Constraint: Ensures that a column cannot have NULL value.
  • DEFAULT Constraint: Provides a default value for a column when none is specified.
  • UNIQUE Constraint: Ensures that all values in a column are different.
  • PRIMARY Key: Uniquely identified each rows/records in a database table.
  • FOREIGN Key: Uniquely identified a rows/records in any another database table.
  • CHECK Constraint: The CHECK constraint ensures that all values in a column satisfy certain conditions.
  • INDEX: Use to create and retrieve data from the database very quickly.

Data Integrity:

The following categories of the data integrity exist with each RDBMS:

  • Entity Integrity: There are no duplicate rows in a table.
  • Domain Integrity: Enforces valid entries for a given column by restricting the type, the format, or the range of values.
  • Referential integrity: Rows cannot be deleted, which are used by other records.
  • User-Defined Integrity: Enforces some specific business rules that do not fall into entity, domain or referential integrity.

Database Normalization

Database normalization is the process of efficiently organizing data in a database. There are two reasons of the normalization process:

  • Eliminating redundant data, for example, storing the same data in more than one tables.
  • Ensuring data dependencies make sense.

Both of these are worthy goals as they reduce the amount of space a database consumes and ensure that data is logically stored. Normalization consists of a series of guidelines that help guide you in creating a good database structure.

Normalization guidelines are divided into normal forms; think of form as the format or the way a database structure is laid out. The aim of normal forms is to organize the database structure so that it complies with the rules of first normal form, then second normal form, and finally third normal form.

It’s your choice to take it further and go to fourth normal form, fifth normal form, and so on, but generally speaking, third normal form is enough.

Source: Tutorials Point

SQL – Overview

sql_new

 

SQL tutorial gives unique learning on Structured Query Language and it helps to make practice on SQL commands which provides immediate results. SQL is a language of database, it includes database creation, deletion, fetching rows and modifying rows etc.

SQL is an ANSI (American National Standards Institute) standard but there are many different versions of the SQL language.

What is SQL?

SQL is Structured Query Language, which is a computer language for storing, manipulating and retrieving data stored in relational database.

SQL is the standard language for Relation Database System. All relational database management systems like MySQL, MS Access, Oracle, Sybase, Informix, postgres and SQL Server use SQL as standard database language.

Also, they are using different dialects, such as:

  • MS SQL Server using T-SQL,
  • Oracle using PL/SQL,
  • MS Access version of SQL is called JET SQL (native format) etc.

Why SQL?

  • Allows users to access data in relational database management systems.
  • Allows users to describe the data.
  • Allows users to define the data in database and manipulate that data.
  • Allows to embed within other languages using SQL modules, libraries & pre-compilers.
  • Allows users to create and drop databases and tables.
  • Allows users to create view, stored procedure, functions in a database.
  • Allows users to set permissions on tables, procedures, and views

History:

  • 1970 — Dr. Edgar F. “Ted” Codd of IBM is known as the father of relational databases. He described a relational model for databases.
  • 1974 — Structured Query Language appeared.
  • 1978 — IBM worked to develop Codd’s ideas and released a product named System/R.
  • 1986 — IBM developed the first prototype of relational database and standardized by ANSI. The first relational database was released by Relational Software and its later becoming Oracle.

SQL Process:

When you are executing an SQL command for any RDBMS, the system determines the best way to carry out your request and SQL engine figures out how to interpret the task.

There are various components included in the process. These components are Query Dispatcher, Optimization Engines, Classic Query Engine and SQL Query Engine, etc. Classic query engine handles all non-SQL queries but SQL query engine won’t handle logical files.

Following is a simple diagram showing SQL Architecture:

SQL Architecture

SQL Commands:

The standard SQL commands to interact with relational databases are CREATE, SELECT, INSERT, UPDATE, DELETE and DROP. These commands can be classified into groups based on their nature:

DDL – Data Definition Language:

Command Description
CREATE Creates a new table, a view of a table, or other object in database
ALTER Modifies an existing database object, such as a table.
DROP Deletes an entire table, a view of a table or other object in the database.

DML – Data Manipulation Language:

Command Description
SELECT Retrieves certain records from one or more tables
INSERT Creates a record
UPDATE Modifies records
DELETE Deletes records

DCL – Data Control Language:

Command Description
GRANT Gives a privilege to user
REVOKE Takes back privileges granted from user

 

Source: Tutorials Point

JavaScript – Overview

javascript_logo

What is JavaScript ?

Javascript is a dynamic computer programming language. It is lightweight and most commonly used as a part of web pages, whose implementations allow client-side script to interact with the user and make dynamic pages. It is an interpreted programming language with object-oriented capabilities.

JavaScript was first known as LiveScript, but Netscape changed its name to JavaScript, possibly because of the excitement being generated by Java. JavaScript made its first appearance in Netscape 2.0 in 1995 with the nameLiveScript. The general-purpose core of the language has been embedded in Netscape, Internet Explorer, and other web browsers.

The ECMA-262 Specification defined a standard version of the core JavaScript language.

  • JavaScript is a lightweight, interpreted programming language.
  • Designed for creating network-centric applications.
  • Complementary to and integrated with Java.
  • Complementary to and integrated with HTML.
  • Open and cross-platform

Client-side JavaScript

Client-side JavaScript is the most common form of the language. The script should be included in or referenced by an HTML document for the code to be interpreted by the browser.

It means that a web page need not be a static HTML, but can include programs that interact with the user, control the browser, and dynamically create HTML content.

The JavaScript client-side mechanism provides many advantages over traditional CGI server-side scripts. For example, you might use JavaScript to check if the user has entered a valid e-mail address in a form field.

The JavaScript code is executed when the user submits the form, and only if all the entries are valid, they would be submitted to the Web Server.

JavaScript can be used to trap user-initiated events such as button clicks, link navigation, and other actions that the user initiates explicitly or implicitly.

Advantages of JavaScript

The merits of using JavaScript are −

  • Less server interaction − You can validate user input before sending the page off to the server. This saves server traffic, which means less load on your server.
  • Immediate feedback to the visitors − They don’t have to wait for a page reload to see if they have forgotten to enter something.
  • Increased interactivity − You can create interfaces that react when the user hovers over them with a mouse or activates them via the keyboard.
  • Richer interfaces − You can use JavaScript to include such items as drag-and-drop components and sliders to give a Rich Interface to your site visitors.

Limitations of JavaScript

We cannot treat JavaScript as a full-fledged programming language. It lacks the following important features −

  • Client-side JavaScript does not allow the reading or writing of files. This has been kept for security reason.
  • JavaScript cannot be used for networking applications because there is no such support available.
  • JavaScript doesn’t have any multithreading or multiprocessor capabilities.

Once again, JavaScript is a lightweight, interpreted programming language that allows you to build interactivity into otherwise static HTML pages.

JavaScript Development Tools

One of major strengths of JavaScript is that it does not require expensive development tools. You can start with a simple text editor such as Notepad. Since it is an interpreted language inside the context of a web browser, you don’t even need to buy a compiler.

To make our life simpler, various vendors have come up with very nice JavaScript editing tools. Some of them are listed here −

  • Microsoft FrontPage − Microsoft has developed a popular HTML editor called FrontPage. FrontPage also provides web developers with a number of JavaScript tools to assist in the creation of interactive websites.
  • Macromedia Dreamweaver MX − Macromedia Dreamweaver MX is a very popular HTML and JavaScript editor in the professional web development crowd. It provides several handy prebuilt JavaScript components, integrates well with databases, and conforms to new standards such as XHTML and XML.
  • Macromedia HomeSite 5 − HomeSite 5 is a well-liked HTML and JavaScript editor from Macromedia that can be used to manage personal websites effectively, from an  Web Company

Where is JavaScript Today ?

The ECMAScript Edition 5 standard will be the first update to be released in over four years. JavaScript 2.0 conforms to Edition 5 of the ECMAScript standard, and the difference between the two is extremely minor.

Today, Netscape’s JavaScript and Microsoft’s JScript conform to the ECMAScript standard, although both the languages still support the features that are not a part of the standard.

 

Source: Tutorials Point

HTML 5 Features: What Web Developers Can Use NOW

There are several articles that list some important upcoming features of HTML5, which can work on certain browsers. This tutorial for the web developer will show you how you can use certain features of HTML 5 NOW!

HTML 5 features which are useful right now include:

  • Web Workers: Certain web applications use heavy scripts to perform functions. Web Workers use separate background threads for processing and it does not effect the performance of a web page.
  • Video: You can embed video without third-party proprietary plug-ins or codec. Video becomes as easy as embedding an image.
  • Canvas: This feature allows a web developer to render graphics on the fly. As with video, there is no need for a plug in.
  • Application caches: Web pages will start storing more and more information locally on the visitor’s computer. It works like cookies, but where cookies are small, the new feature allows for much larger files. Google Gears is an excellent example of this in action.
  • Geolocation: Best known for use on mobile devices, geolocation is coming with HTML5.

If you want to know if any of the above features works on a given browser, you can test for it through Modernizer. This small JavaScript library is good for detecting CSS3 as well. From the Modernizer web site, “Modernizr is a small and simple JavaScript library that helps you take advantage of emerging web technologies (CSS3, HTML 5) while still maintaining a fine level of control over older browsers that may not yet support these new technologies.”

The Modernizer syntax is intuitive:

.multiplebgs div p {
  /* properties for browsers that
     support multiple backgrounds */
}
.no-multiplebgs div p {
  /* optional fallback properties
     for browsers that don't */
}
The Challenges of Cloud Integration

Simply insert the modernizr-1.1.js JavaScript file in your page and add a class of “no-js” in the <html> element. You can then use the Modernizr JavaScript object and the various CSS classes it attaches to the html element. Here’s an example of how to do that:

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Learning HTML5</title>
  <script src="modernizr.min.js"></script>
</head>
<body>
  Your web page here.
</body>
</html>

For those of you with a keen eye, you might have noticed the simplified <!DOCTYPE html>

If you’re still using,

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

as your doctype, you can simplify and shorten it right now. This works in all browsers. You can also shorten,

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

To

<meta charset="utf-8">

In addition, you can shorten the reference to your CSS from:

<style type="text/css">

To <style> Of course, that only works for embedded or inline style sheets. It does not work for external style sheets.

If you use JavaScript in your web page, you can short the syntax there as well. Here’s the original code from part of a Google search box:

<script type="text/javascript" src="http://www.google.com/cse/brand?form=cse-search-box&amp;lang=en"></script>

You can shorten this by deleting “text/javascript” I have tested all of the above in my personal site and everything still works in Internet Explorer, Firefox and Chrome. I’ve said it before and I’ll say it again, for me, the best part of HTML5 is the cleaner, simpler and shorter code. In the long run, web pages will run faster and smoother than ever before with less chances of coding mistakes.

Source Html goodies

Posts navigation

1 2