28 Exciting And Fresh jQuery Navigation Plugins

Navigation is doubtlessly the most important and critical part of the website designing process. This is that part of the website where the creative skills of all the designers are tested as they have to make the navigation very easy for the users and yet at the same time uniquely creative. Navigation is extremely important for almost all the websites as it allows the designers to neatly categorize their websites into different parts where users can surf for the required information pertaining to that particular part. So it can safely said that the navigation process should be so easy that the user doesn’t have to think at all as to where he/she should go for what he/she requires and yet the interface should also be alluring enough that the user retains a great experience.

We have therefore collected for all the website developers some fresh and exciting JQuery plugins that will look excellent in all websites. These amazing plugins will definitely inspire you and take your design to the next best level!!

Sidr

The best jQuery plugin for creating side menus and the easiest way for doing your menu responsive.

navigationplugin

Smart Menus

jQuery website menu plugin. Responsive and accessible list-based website menus that work on all devices.

navigationplugin

Slimmenu

SlimMenu is a lightweight jQuery plugin, which is made to create responsive and multi-level navigation menus on the fly.

navigationplugin

Flexible Navigation

FlexNav is a mobile-first example of using media queries and javascript to make a decent multi-level menu with support for touch, hover reveal, and keyboard tab input accessibility. Special attention is paid to touch screens using tap targets (the key feature of FlexNav).

navigationplugin

DdSlick

Ddslick a free light weight jQuery plugin that allows you to create a custom drop down with images and description.

navigationplugin

Toolbar.js

Toolbar allows you to quickly create tooltip style toolbars for use in web applications and websites. The toolbar is easily customisable using the twitter bootstrap icons and provides flexability around the toolbars display and number of icons.

navigationplugin

jMenu

jMenu is a jQuery plugin that enables us to create horizontal navigations with unlimited sub-menus.Besides jQuery, it also requires jQuery UI and supports all the effects of this library (like fadeIn or slideDown).

navigationplugin

Navgoco

Navgoco is a simple JQuery plugin which turns a nested unordered list of links into a beautiful vertical multi-level slide navigation, with ability to preserve expanded submenus between sessions by using cookies and optionally act as an accordion menu.

navigationplugin

jQuery Easy DropDown

A Drop-down Builder for Styleable Inputs and Menus.

navigationplugin

Intro.js

Better introductions for websites and features with a step-by-step guide for your projects.

navigationplugin

jPanelmenu

jPanelMenu is a jQuery plugin that creates a paneled-style menu (like the type seen in the mobile versions of Facebook and Google, as well as in many native iPhone applications).

navigationplugin

HorizontalNav

HorizontalNav is a jQuery plugin that spans a horizontal navigation to fit the full width of it’s container. If you’ve ever had to create this effect on a project, you’ll know it’s pretty annoying to do. But this plugin makes it easy and adds support for IE7.

navigationplugin

TinyNav.js

TinyNav.js is a tiny jQuery plugin (452 bytes minified and gzipped) that converts ul and ol navigations to a select dropdowns for small screen. It also automatically selects the current page and adds selected=”selected” for that item.

navigationplugin

jQuery Listnav Plugin

This jQuery plugin supplies an easy way to unobtrusively add a letter-based navigation widget to any UL or OL list. An easily stylable (via CSS) nav bar appears above the list, showing the user the letters A-through-Z.

navigationplugin

jPaginator

jPaginator is a jQuery plugin for pagination. It’s fun, intuitive, it comes with a slider and you can ask for an unlimited number of pages. Use it with a unique element, for more details please have a look at the code of demo1 and the plugin’s options.

navigationplugin

Akordeon

Akordeon is a stylish jQuery plugin for adding efficient accordion style menu to a web page. The idea behind Akordeon is to provide a lightweight and customizable interface for collapsible panels that can hold any kind of data in a limited space.

Responsive Nav

Responsive navigation plugin without library dependencies and with fast touch screen support.

Snap.js

A Library for creating beautiful mobile shelfs in Javascript (Facebook and Path style side menus).

Responsive Side Toggle Menu

Side Toggle Menu lets you add a side bar menu to your page that slides in from the left or right edge of the browser window. It supports two types of unveiling- either by nudging the rest of the page and making room for itself, or overlaying the page.

ScrollNav

scrollNav is a light jQuery plugin that grabs your page’s existing content, divides it up into logical sections and builds a customizable scrolling sidebar navigation. Scroll this page and watch the nav follow along with you.

SlickNav

Responsive Mobile Menu Plugin for jQuery.

Smart Menus

Drop-Down Navigation: Responsive and Touch-Friendly

Vertical Flyout JavaScript Menu

This animated JavaScript flyout menu is clean and lightweight at only 1.6kb.

jQuery Menu Aim

jQuery plugin to fire events when user’s cursor aims at particular dropdown menu items. For making responsive mega dropdowns like Amazon’s.

jQuery Mmenu

A jQuery plugin for creating slick, app look-alike sliding menus for you mobile website with only one line of javascript.

Flaunt.js

Flaunt JS, stylish responsive navigations with nested click to reveal.

Mean Menu

A menu system for converting a standard menu into a mobile/tablet responsive menu, media query independent.

Learn PHP from Scratch

Holding the title of “number one”, PHP is the most popular language among developers. Even still, many prefer different languages. Yours truly, for example, is most comfortable when working in the ASP.NET environment. However, because of the enormous success of WordPress, more and more developers have decided to expand their horizons and learn yet another language.

 

I happen to be one of those very people. As my clients increasingly ask for WordPress implementation, learning PHP has become a requirement. I’m not alone in this endeavor. For those in the same boat, why not take the time and learn with me?

The Mission Statement

Over the course of the next few articles – to be posted each Wednesday – it is my intention to create a “work-out regimen” for all of us. If you’ve been meaning to learn, but haven’t gotten around to it yet, now is the time! On the flip side, for those of you who are PHP ninjas, I respectfully request that you get involved and offer advice to the rest of us. If you’ve benefited from the dozens of tutorials on this site, take a few moments to give back, via the comments section. This will be your one-stop resource for everything PHP. Each Wednesday, I’ll post a training article, as well as a list of resources that will help to explain the concepts in the lesson further. The key here is that I’m a beginner just like everyone else, relatively speaking. We can motivate one another to learn as quickly, and efficiently as possible.

So, why would you learn from a beginner? Try not to think of it as me teaching you. Think of these articles as a community effort where we all help each other. I’ll be learning from many of you in the same way that you learn from me.

What Is PHP?

PHP stands for Hypertext Preprocessor. While other languages, like Javascript, function on the client-side, your PHP code will execute on the server level. It works seamlessly with our HTML. Furthermore, your PHP can be embedded within your HTML and vice versa. The important thing to remember is that, no matter how complicated your PHP is, it will ultimately be output as simple HTML.

Why Would I Use PHP?

HTML is 100% static. By implementing PHP into your code, we can create dynamic sites that will change dependent upon specified conditions. With a community base second to none, this open-source language has proven itself over the years to be one of the best options for dynamic web applications.

Is PHP Similar To Any Other Languages?

Absolutely. I was pleasantly surprised as I began my training. If you have even a modest amount of knowledge when it comes to ASP.NET, Perl, Javascript, or C#, you’ll find that you pick up the syntax quickly.

What Do I Need To Get Started?

You must have the following installed on your computer in order to begin.

  • Apache
  • MySQL
  • Web Browser
  • Text Editor
  • PHP

WAMP, MAMP

Yes, I’m sorry to say that there are a few more acronyms to learn. “WAMP” stands for “Windows-Apache-MySQL-PHP”. It is an open source project that will allow us to download everything that we need to get started right away. If you’re a Windows user, visit WampServer.com. On the other hand, if you’re using a Mac (MAMP), you’ll want to pay a visit to Mamp.info

The Basics

In order to alert the server that we are working with PHP, you’ll need to use the following syntax when adding PHP into your HTML documents:

1
2
3
<?php
...code goes here
?>

We start and end each PHP declaration with “<?php” and “?>”, respectively. Refer back to your code and insert the following:

1
<?php echo "This is PHP in action"; ?>

Notice that in this second example, we kept everything on one line. Remember, PHP is not white-space sensitive. Here, we are telling the server to “echo”, or write “This is PHP in action” onto the page. Each declaration in our code must have a semicolon appended to the end. Although HTML can be forgiving if you accidentally forget a bracket, PHP unfortunately is not. If you don’t use the correct syntax, you’ll receive an error. In this case, when we only have a single declaration, we could technically get away with leaving the semicolon off. But, it’s always important to follow best practices.

Defining Variables

We can assign values to variables quite easily. Rather than using “var” (C# and Javascript), or “dim” (VB), we can declare a variable in PHP by using the “$” symbol. For instance, let’s say that I want to assign the previous string to a variable called “myVariable”. I would write…

1
2
3
<?php $myVariable "This is PHP in action";
  echo $myVariable;
?>

This example will produce the exact same result as the previous two. However, in this scenario, we’ve assigned the string to the variable and then “echoed” the variable instead. Now what if I wanted to concatenate a variable and a string?

1
2
3
<?php $myVariable "This is PHP in action.";
  echo $myVariable . " My name is Jeffrey Way";
?>

By using the period, we can combine variables and/or strings.

Inserting Comments Into Your Code

If you’re familiar with CSS and Javascript, you’ll find that inserting comments in PHP is virtually the same.

<?php
  # This is a single line comment.
  // This is the most common way of commenting out your code.
  /* Here is a way to comment over multiple lines. This is the exact
     same way that you would comment in CSS */
?>

Combining HTML With Our PHP

As said previously, remember that PHP and HTML can work in combination. Simply because we’re in the middle of a PHP statement does not mean that we can’t embed elements such as a break or strong tag.

<?php echo "<strong>This text is bold.</strong>"; ?>

Defining Your First Function()

Creating functions in PHP is nearly identical to Javascript’s implementation. The basic syntax is…

<?php
function name ($arguments){
your statement goes here;
}
?>

If we wanted to create a function that “echos” 10 plus 5, we could write…

1
2
3
4
5
6
<?php
function addNumbers (){
echo 10 + 5;
}
addNumbers();
?>

We’re creating a simple function that will output “15″. We call the function with “addNumbers(). In this case, we aren’t using any arguments. Let’s see how we can implement them in order to make our function more versatile.

1
2
3
4
5
6
<?php
function addNumbers($firstNumber, $secondNumber){
echo $firstNumber + $secondNumber;
}
addNumbers(10, 5);
?>

Now, our code is much more flexible. When we created our “addNumbers()” function, we added two arguments – $firstNumber and $secondNumber. The function will simply echo the sum of these two variables. When the function is called, we’ll need to pass in our two numbers – addNumbers(10, 5). In a real-world situation, the values for these variables might be taken from a couple of textboxes.

That should be enough for this week. If these concepts are still vague, go back and read the article again. Also, be sure to check out the following resources which will help you to further grasp the syntax of PHP. Please feel free to ask questions or offer advice in the comment section. I’ll be sure to work your thoughts into Part 2 – which will come out next Wednesday. If you enjoyed this article, please submit it to your favorite social networking site!

jQuery and JavaScript Coding: Examples and Best Practices

Things to do today..

When used correctly, jQuery can help you make your website more interactive, interesting and exciting. This article will share some best practices and examples for using the popular Javascript framework to create unobtrusive, accessible DOM scripting effects. The article will explore what constitutes best practices with regard to Javascript and, furthermore, why jQuery is a good choice of a framework to implement best practices.

1. Why jQuery?

jQuery is ideal because it can create impressive animations and interactions. jQuery is simple to understand and easy to use, which means the learning curve is small, while the possibilities are (almost) infinite.

JAVASCRIPT AND BEST PRACTICES

Javascript has long been the subject of many heated debates about whether it is possible to use it while still adhering to best practices regarding accessibility and standards compliance.

The answer to this question is still unresolved, however, the emergence of Javascript frameworks like jQuery has provided the necessary tools to create beautiful websites without having to worry (as much) about accessibility issues.

Obviously there are cases where a Javascript solution is not the best option. The rule of thumb here is: use DOM scripting to enhance functionality, not create it.

UNOBTRUSIVE DOM SCRIPTING

While the term “DOM scripting” really just refers to the use of scripts (in this case, Javascripts) to access the Document Object Model, it has widely become accepted as a way of describing what should really be called “unobtrusive DOM scripting”—basically, the art of adding Javascript to your page in such a way that if there were NO Javascript, the page would still work (or at least degrade gracefully). In the website world, our DOM scripting is done using Javascript.

THE BOTTOM LINE: ACCESSIBLE, DEGRADABLE CONTENT

The aim of any web producer, designer or developer is to create content that is accessible to the widest range of audience. However, this has to be carefully balanced with design, interactivity and beauty. Using the theories set out in this article, designers, developers and web producers will have the knowledge and understanding to use jQuery for DOM scripting in an accessible and degradable way; maintaining content that is beautiful, functional AND accessible.

2. Unobtrusive DOM Scripting?

In an ideal world, websites would have dynamic functionality AND effects that degrade well. What does this mean? It would mean finding a way to include, say, a snazzy Javascript Web 2.0 animated sliding news ticker widget in a web page, while still ensuring that it fails gracefully if a visitor’s browser can’t (or won’t) run Javascripts.

The theory behind this technique is quite simple: the ultimate aim is to use Javascript for non-invasive, “behavioural” elements of the page. Javascript is used to add or enhance interactivity and effects. The primary rules for DOM scripting follow.

RULE #1: SEPARATE JAVASCRIPT FUNCTIONALITY

Separate Javascript functionality into a “behavioural layer,” so that it is separate from and independent of (X)HTML and CSS. (X)HTML is the markup, CSS the presentation and Javascript the behavioural layer. This means storing ALL Javascript code in external script files and building pages that do not rely on Javascript to be usable.

For a demonstration, check out the following code snippets:

CrossBAD MARKUP:

Never include Javascript events as inline attributes. This practice should be completely wiped from your mind.

<a onclick="doSomething()" href="#">Click!</a>
TickGOOD MARKUP:

All Javascript behaviours should be included in external script files and linked to the document with a <script> tag in the head of the page. So, the anchor tag would appear like this:

<a href="backuplink.html" class="doSomething">Click!</a>

And the Javascript inside the myscript.js file would contain something like this:

...

$('a.doSomething').click(function(){
	// Do something here!
	alert('You did something, woo hoo!');
});
...

The .click() method in jQuery allows us to easily attach a click event to the result(s) of our selector. So the code will select all of the <a> tags of class “doSomething” and attach a click event that will call the function. In practice, this

In Rule #2 there is a further demonstration of how a similar end can be achieved without inline Javascript code.

RULE #2: NEVER DEPEND ON JAVASCRIPT

To be truly unobtrusive, a developer should never rely on Javascript support to deliver content or information. It’s fine to use Javascript to enhance the information, make it prettier, or more interactive—but never assume the user’s browser will have Javascript enabled. This rule of thumb can in fact be applied to any third-party technology, such as Flash or Java. If it’s not built into every web browser (and always enabled), then be sure that the page is still completely accessible and usable without it.

CrossBAD MARKUP:

The following snippet shows Javascript that might be used to display a “Good morning” (or “afternoon”) message on a site, depending on the time of day. (Obviously this is a rudimentary example and would in fact probably be achieved in some server-side scripting language).

<script language="javascript">
var now = new Date();
if(now.getHours() < 12)
	document.write('Good Morning!');
else
	document.write('Good Afternoon!');
</script>

This inline script is bad because if the target browser has Javascript disabled, NOTHING will be rendered, leaving a gap in the page. This is NOT graceful degradation. The non-Javascript user is missing out on our welcome message.

TickGOOD MARKUP:

A semantically correct and accessible way to implement this would require much simpler and more readable (X)HTML, like:

<p title="Good Day Message">Good Morning!</p>

By including the “title” attribute, this paragraph can be selected in jQuery using a selector (selectors are explained later in this article) like the one in the following Javascript snippet:

var now = new Date();
if(now.getHours() >= 12)
{
	var goodDay = $('p[title="Good Day Message"]');
	goodDay.text('Good Afternoon!');
}

The beauty here is that all the Javascript lives in an external script file and the page is rendered as standard (X)HTML, which means that if the Javascript isn’t run, the page is still 100% semantically pure (X)HTML—no Javascript cruft. The only problem would be that in the afternoon, the page would still say “Good morning.” However, this can be seen as an acceptable degradation.

RULE #3: SEMANTIC AND ACCESSIBLE MARKUP COMES FIRST

It is very important that the (X)HTML markup is semantically structured. (While it is outside the scope of this article to explain why, see the links below for further reading on semantic markup.) The general rule here is that if the page’s markup is semantically structured, it should follow that it is also accessible to a wide range of devices. This is not always true, though, but it is a good rule of thumb to get one started.

Semantic markup is important to unobtrusive DOM scripting because it shapes the path the developer will take to create the DOM scripted effect. The FIRST step in building any jQuery-enhanced widget into a page is to write the markup and make sure that the markup is semantic. Once this is achieved, the developer can then use jQuery to interact with the semantically correct markup (leaving an (X)HTML document that is clean and readable, and separating the behavioural layer).

CrossTERRIBLE MARKUP:

The following snippet shows a typical list of items and descriptions in a typical (and terribly UNsemantic) way.

<table>
    <tr>
        <td onclick="doSomething();">First Option</td>
        <td>First option description</td>
    </tr>
    <tr>
        <td onclick="doSomething();">Second Option</td>
        <td>Second option description</td>
    </tr>
</table>
CrossBAD MARKUP:

The following snippet shows a typical list of items and descriptions in a more semantic way. However, the inline Javascript is far from perfect.

<dl>
    <dt onclick="doSomething();">First Option</dt>
    <dd>First option description</dd>
    <dt onclick="doSomething();">Second Option</dt>
    <dd>Second option description</dd>
</dl>
TickGOOD MARKUP:

This snippet shows how the above list should be marked up. Any interaction with Javascript would be attached at DOM load using jQuery, effectively removing all behavioural markup from the rendered (X)HTML.

<dl id="OptionList">
    <dt>First Option</dt>
    <dd>First option description</dd>
    <dt>Second Option</dt>
    <dd>Second option description</dd>
</dl>

The <id> of “OptionList” will enable us to target this particular definition list in jQuery using a selector—more on this later.

3. Understanding jQuery for Unobtrusive DOM Scripting

This section will explore three priceless tips and tricks for using jQuery to implement best practices and accessible effects.

UNDERSTANDING SELECTORS: THE BACKBONE OF JQUERY

The first step to unobtrusive DOM scripting (at least in jQuery and Prototype) is using selectors. Selectors can (amazingly) select an element out of the DOM tree so that it can be manipulated in some way.

If you’re familiar with CSS then you’ll understand selectors in jQuery; they’re almost the same thing and use almost the same syntax. jQuery provides a special utility function to select elements. It is called $.

A SET OF VERY SIMPLE EXAMPLES OF JQUERY SELECTORS:
$(document); // Activate jQuery for object
$('#mydiv')  // Element with ID "mydiv"
$('p.first') // P tags with class first.
$('p[title="Hello"]') // P tags with title "Hello"
$('p[title^="H"]') // P tags title starting with H
SO, AS THE JAVASCRIPT COMMENTS SUGGEST:
  1. $(document);
    The first option will apply the jQuery library methods to a DOM object (in this case, the document object).
  2. $(‘#mydiv’)
    The second option will select every <div> that has the <id> attribute set to “mydiv”.
  3. $(‘p.first’)
    The third option will select all of the <p> tags with the class of “first”.
  4. $(‘p[title="Hello"]‘)
    This option will select from the page all <p> tags that have a title of “Hello”. Techniques like this enable the use of much more semantically correct (X)HTML markup, while still facilitating the DOM scripting required to create complex interactions.
  5. $(‘p[title^="H"]‘)
    This enables the selection of all of the <p> tags on the page that have a title that starts with the letter H.
THESE EXAMPLES BARELY SCRATCH THE SURFACE.

Almost anything you can do in CSS3 will work in jQuery, plus many more complicated selectors. The complete list of selectors is well documented on the jQuery Selectors documentation page. If you’re feeling super-geeky, you could also read the CSS3 selector specification from the W3C.

GET READY.
$(DOCUMENT).READY()

Traditionally Javascript events were attached to a document using an “onload” attribute in the <body> tag of the page. Forget this practice. Wipe it from your mind.

jQuery provides us with a special utility on the document object, called “ready”, allowing us to execute code ONLY after the DOM has completely finished loading. This is the key to unobtrusive DOM scripting, as it allows us to completely separate our Javascript code from our markup. Using $(document).ready(), we can queue up a series of events and have them execute after the DOM is initialized.

This means that we can create entire effects for our pages without changing the markup for the elements in question.

HELLO WORLD! WHY $(DOCUMENT).READY() IS SO COOL

To demonstrate the beauty of this functionality, let’s recreate the standard introduction to Javascript: a “Hello World” alert box.

The following markup shows how we might have run a “Hello World” alert without jQuery:

CrossBAD MARKUP:
<script language="javascript">
alert('Hello World');
</script>
TickGOOD MARKUP:

Using this functionality in jQuery is simple. The following code snippet demonstrates how we might call the age-old “Hello World” alert box after our document has loaded. The true beauty of this markup is that it lives in an external Javascript file. There is NO impact on the (X)HTML page.

$(document).ready(function()
{
	alert('Hello World');
});
HOW IT WORKS

The $(document).ready() function takes a function as its argument. (In this case, an anonymous function is created inline—a technique that is used throughout the jQuery documentation.) The function passed to $(document).ready() is called after the DOM has finished loading and executes the code inside the function, in this case, calling the alert.

DYNAMIC CSS RULE CREATION

One problem with many DOM scripting effects is that they often require us to hide elements of the document from view. This hiding is usually achieved through CSS. However, this is less than desirable. If a user’s browser does not support Javascript (or has Javascript disabled), yet does support CSS, then the elements that we hide in CSS will never be visible, since our Javascript interactions will not have run.

The solution to this comes in the form of a plugin for jQuery called cssRule, which allows us to use Javascript to easily add CSS rules to the style sheet of the document. This means we can hide elements of the page using CSS—however the CSS is ONLY executed IF Javascript is running.

CrossBAD MARKUP:
HTML:
<h2>This is a heading</h2>
<p class="hide-me-first">
This is some information about the heading.
</p>

CSS:
p.hide-me-first
{
	display: none;
}

Assuming that a paragraph with the class of “hide-me-first” is going to first be hidden by CSS and then be displayed by a Javascript after some future user interaction, if the Javascript never runs the content will never be visible.

TickGOOD MARKUP:
HTML:
<h2>This is a heading</h2>
<p class="hide-me-first">
This is some information about the heading.
</p>

jQuery Javascript:
$(document).ready(function{
	jQuery.cssRule("p.hide-me-first", "display", "none");
});

Using a $(document).ready() Javascript here to hide the paragraph element means that if Javascript is disabled, the paragraphs won’t ever be hidden—so the content is still accessible. This is the key reason for runtime, Javascript-based, dynamic CSS rule creation.

4. Conclusion

jQuery is an extremely powerful library that provides all the tools necessary to create beautiful interactions and animations in web pages, while empowering the developer to do so in an accessible and degradable manner.

This article has covered:

  1. Why unobtrusive DOM scripting is so important for accessibility,
  2. Why jQuery is the natural choice to implement unobtrusive DOM scripting effects,
  3. How jQuery selectors work,
  4. How to implement unobtrusive CSS rules in jQuery.

40 CSS3/jQuery Loading Animation And Progress Bar Plugins

Another amazing and wonderful collection of jQuery and CSS3 for you is presented here. In this collection we are showcasing 40 jQuery and CSS3 loading animation and progress bar plugins and tutorial. One thing keep in your mind that CSS3 animations are not yet supported in old browsers so you have to try modern browsers if you want to see the live action of these outstanding plugins. With loaders and progress bars users know that something is still going on that’s why loaders and progress bars are very essential for users.

With these loading animations and progress bars you can make your web application and websites more stunning and eye-catching. All these jQuery and CSS3 loading animation and progress bar also help you to enhance the performance of your websites or web application. This is the reason loaders and progress bars are very famous and trendy these days. Take a look and let me know what you think.

Loader Bar

Demo | Download )

Animated Progress Bar

Demo | Download )

Animated Progress Bar in 4 Lines of jQuery

Demo | Download )

CSS3 Loading Animation

Demo | Download )

Beautiful CSS3 And jQuery progress Bar

Demo | Download )

CSS3 Loading Animation Loop

Demo | Download )

dwProgressBar

Demo | Download )

Pure CSS Progress Bar

Demo | Download )

Smooth Progress Bar Loading Effect

Demo | Download )

Animated Skills Diagram with Raphael

Demo | Download )

Creating & Styling Progress Bar With HTML5

Demo | Download )

Animated Progress Bars with CSS3

Demo | Download )

Spin JS Bar

Demo | Download )

The Facebook loading animation

Demo | Download )

Flickr Style Loading Animation

Demo | Download )

CSS3 Loading Spinners Without Images

Demo | Download )

Sonic.js

Demo | Download )

QueryLoader2 – Preload your images with ease

Demo | Download )

jQuery Progress Bar

Demo | Download )

jQuery Ajax Loader & Spinner

Demo | Download )

Animated jQuery Progressbar

Demo | Download )

CSS3 Progress Bars

Demo | Download )

Automatic Page Load & Ajax Request Progress Bar

Demo | Download )

CSS Load

Demo | Download )

Mambo

Demo | Download )

Google Like jQuery Slim Progress Bar Plugin

Demo | Download )

CanvasLoader Creator

Demo | Download )

Ajax Style Loading Animation

Demo | Download )

Animated Progress Bar

Demo | Download )

Fine Uploader

Demo | Download )

jQuery Ajax Loading Overlay with Loading Text

Demo | Download )

Buttons with Built-in Loading Indicators

Demo | Download )

Form Submit Buttons with Built-in Loading Indicators

Demo | Download )

Automatic Page Load & Ajax Request Progress Bar

Demo | Download )

Form Submit Buttons with Built-in Loading Indicators

Demo | Download )

Real Time Hints & Progress For Forms

Demo | Download )

jQuery Plugin For Detecting Image Have Been Loaded

Demo | Download )

Tiny jQuery Plugin For Animated Loading Spinners

Demo | Download )

Simple and Customizable jQuery Loading Animation Plugin

Demo | Download )

jQuery Animated Bar Plugin

Demo | Download )

Read more: http://www.smashingapps.com/2014/02/24/40-jquery-css3-loading-animation-and-progress-bar-plugins.html#ixzz2uH5ffsEP

45 Must Have WordPress Plugins For Your Blog

Here we are showcasing 45 Essential WordPress plugins that will make blogging even more interesting for you. These days, a wide number of plugins are available for the bloggers that help them share their content and make blogging easier for them, since the competition on the internet is out of control; you definitely need some plugins that can make certain blogging processes easier for you and for your readers as well.

Here, we have put together 45 most essential WordPress plugins that are must to have for every blogger. All of these plugins are free to use and will save plenty of your time. So, browse through this collection and pick as many as you need. Enjoy!

Sociable

Sociable Skyscraper is the ultimate advanced and feature-packed plugin for setting up a rating system on your WordPress blog. This plugin allows you to set up different rating systems for posts, pages and comments with a great degree of customization.

Contact Form 7

Just another contact form plugin. Simple but flexible.

Gigya Socialize

Make Your Site Social by integrating Gigyas social optimization service into your WordPress site.

IntenseDebate

IntenseDebate is a feature-rich comment system for WordPress, Blogger, Tumblr and many other blogging/CMS platforms.

WP-PageNavi

Adds a more advanced paging navigation interface.

Social Metrics

Track how’s your blog doing across the leading social networking websites and services.

Digg Digg

Your all in one share buttons plugin. Add a floating bar with share buttons to your blog. Just like Mashable!

Social Media Widget

The Social Media Widget is a simple sidebar widget that allows users to input their social media website profile URLs and other subscription options to show an icon on the sidebar to that social media site and more that open up in a separate browser window.

The Hello Bar

Easily add your Hello Bar to your WordPress blog with the official Hello Bar for WordPress plugin.

W3 Total Cache

Improve site performance and user experience via caching: browser, page, object, database, minify and content delivery network support.

Follow Button

The Follow Button is a small widget which allows users to easily follow a Twitter account from any webpage. The Follow Button uses the same implementation model as the Tweet Button, and its integration is just as simple.

Janrain Engage

Janrain social login increases site registrations and generates referral traffic to your site by allowing users to easily register and login via an existing social network or email ID.

Facebook / Twitter Status

If you have a Facebook profile or page or a Twitter account, this plugin is what you need to connect them with your blog! When you publish a new wordp

Facebook Fan box

Display a Facebook Fan Box on your blog. Put the Facebook Fan Box in your sidebar using the widget mode or call the function inside your template.

Quick Cache

Speed up your site ~ BIG Time! – If you care about the speed of your site, Quick Cache is a plugin that you absolutely MUST have installed.

SEO Ultimate

This all-in-one SEO plugin gives you control over title tags, noindex, meta tags, slugs, canonical, autolinks, 404 errors, rich snippets, and more.

Akismet

Akismet filters out your comment and track-back spam for you, so you can focus on more important things.

AntiSpam Bee

Anonymous and independent antispam solution. Detect comment and trackback spam. Includes statistics and notifications.

AddThis

The AddThis Social Bookmarking Widget allows any visitor to bookmark and share your site easily with over 330 popular services.

ShareThis

The ShareThis plugin is a quick and easy sharing service that allows your users to share your content to 120 social channels. Also features ShareNow.

WP-Optimize

This simple but effective plugin allows you to clean up your WordPress database and optimize it without phpMyAdmin.

WP Smush.it

Reduce image file sizes and improve performance using the Smush.it API within WordPress.

Robots Meta

This plugin makes it easy to add the appropriate meta robots tags to your pages, disable unused archives, nofollow unnecessary links as well as do som

SI CAPTCHA Anti-Spam

Adds CAPTCHA anti-spam methods to WordPress on the forms for comments, registration, lost password, login, or all. For WP, WPMU, and BuddyPress.

Disqus

Beautiful, real-time, engaging discussions for your website.

OpenID

Allows WordPress to provide and consumer OpenIDs for authentication of users and comments.

WP Ajax Edit Comments

Users can edit their own comments for a limited time, while admins can edit all comments.

Share Buttons By Lockerz

Help people share, bookmark, and email your posts & pages using any service, such as Facebook, Twitter, Google, StumbleUpon, LinkedIn and many mor

WordPress.com Stats

Simple, concise stats with no additional load on your server. Plug into WordPress.com’s stats system with this plugin.

Growmap Anti Spambot Plugin

Defeat automated spambots by adding a client side generated checkbox asking the comment author to confirm that they are not a spammer.

WordPress SEO By Yoast

Improve your WordPress SEO: Write better content and have a fully optimized WordPress site using the WordPress SEO plugin by Yoast.

Google XML Sitemaps

This plugin will generate a special XML sitemap which will help search engines to better index your blog.

Editorial Calendar

The Editorial Calendar makes it possible to see all your posts and drag and drop them to manage your blog.

WP-reCAPTCHA

Integrates reCAPTCHA anti-spam methods with WordPress including comment, registration, and email spam protection.

Facebook Comments For WordPress

This plugin integrates the Facebook commenting system (new, old or both) right into your website. If a reader is logged into Facebook while viewing any comment-enabled page or post, they’ll be able to leave a comment using their Facebook profile.

WP-DBManager

Allows you to optimize database, repair database, backup database, restore database, delete backup database , drop/empty tables and run selected queries. Supports automatic scheduling of backing up, optimizing and repairing of database.

WP Security Scan

WP Security Scan checks your WordPress website/blog for security vulnerabilities and suggests corrective actions.

SEO Smart Links

SEO Smart Links provides automatic SEO benefits for your site in addition to custom keyword lists, nofollow and much more.

Widget Context

Show widgets in context – only on certain posts, front page, category or tag pages etc.

Thank Me Later

Automatically send a ‘thank you’ e-mail to those who comment on your blog. This plugin engages visitors by reminding them to check back for

Floating Social Media Icon

Easy 2 Use Plugin 2 Show SocialMedia Icons That Floats,Can Configure Social Icon Design,Order & Size at Plugin Settings, Suport Widget & Short

Trackable Social Share Icons

The Trackable Social Share Icons plugin enables blog readers to easily share posts via social media networks, including Facebook and Twitter.

Stumbleupon & Digg Thumbnail Maker

Stumbleupon & Digg Thumbnail Maker allows you to specifically select a thumbnail for a post when it is submitted to some social media sites.

Social Media Mashup

Combine Twitter, Facebook, Google+, Flickr, YouTube, and custom RSS feeds into one stream.

GetSocial

GetSocial adds an intelligent, lightweight, quick to setup floating social media sharing box on your blog posts.

Conclusion

In this round up, you have discovered some exceptionally essential WordPress plugins that every WordPress user must know. WordPress no doubt is a wonderful tool and availability of its various plugins makes it even more wonderful tool to be used for blogging purpose. Above, you will discover 45 useful and essential plugins for WordPress. Take a look at this collection and share your comments with us via comment section below. Enjoy!

Read more: http://www.smashingapps.com/2014/02/10/45-must-have-wordpress-plugins-for-your-blog.html#ixzz2uBBn7qq5

6 Do(s)and Not to do(s) for C# developers

1. Try to avoid using the “ref” and “out” keywords.

There is rarely a situation that you really have to use “ref” or “out” keywords. It should be avoided as much as possible, because when you use them it means that your method probably tries to do too much (and therefore breaks the Single Responsibility Principle). It can also make your method less readable. To accomplish the goal of not using ref/out keywords it is usually enough to create a class that will represent multiple return values and then return an instance of this class as a result of the method. There are obviously situations when the usage of ref/out cannot be avoided like when using TryParse method, but these should be treated as exceptions to the rule.

2. Do not use OrderBy before Where

The above statement might sound very obvious but anyway some developers tend to forget about this. Let’s take a look at the following code:

1
2
3
var allCitiesInPoland =
    allCitiesInTheWorld.OrderBy(x => x.Name)
                       .Where(x => x.Country == Country.Poland);

In this hypothetical scenario firstly the collection of all cities in the world (according to some statistics: 2,469,501) will be sorted and then only these from Poland (897) will be returned. The result will be appropriate, the only problem is that it will be simply inefficient. Using the following code:

1
2
3
var allCitiesInPoland =
    allCitiesInTheWorld.Where(x => x.Country == Country.Poland)
                       .OrderBy(x => x.Name);

First of all we will choose only the cities from Poland and then order this significantly smaller collection alphabetically by name.

3. Always use Properties instead of public variables

When using getters and setters you can restrict the user directly from accessing the member variables. Secondly, you can explicitly restrict setting the values. Thanks to this you make your data protected from accidental changes. What is more, when using properties,  it is much easier to validate your data.

4. Take advantage of string.IsNullOrEmpty() and string.IsNullOrWhiteSpace()

Instead of:

1
2
3
4
if (name != null && name != string.Empty)
{
    [...]
}

It’s better to use:

1
2
3
4
if (string.IsNullOrEmpty(name))
{
    [...]
}

Sometimes we want to make sure that a string is not only not empty and not null, but also does not comprise of whitespaces. In such situation we could of course use the following code:

1
2
3
4
if (string.IsNullOrEmpty(name.Trim()))
{
    [...]
}

But why not using something that is already provided by the .NET framework (in version 4.0 and higher):

1
2
3
4
if (string.IsNullOrWhiteSpace(name))
{
    [...]
}

The example above can be treated as a more general principle. You should simply always try to find out whether something that you implemented is not already existing as a ready method in the framework that you use. Make sure that you went through all the methods in such .Net classes as e.g. String or IO.Path. This might potentially save you some time that you could have spent on reinventing the wheel.

5. Understand the difference between First() and Single()

Always remember that First() returns the very first item of the sequence, if no item exists it throws InvalidOperationException, whereas Single() Returns the only item in the sequence, if no item exists it throws InvalidOperationException,and if more than one item exists, it also throws InvalidOperationException.

6. Do not blindly use List

There are some cases when the usage of List is simply not recommended from performance point of view. You should be aware of the existence of e.g. HashSet or SortedSet which can considerably improve the performance, especially in case of large sets of items. To make you aware of how big the difference in performance between these two is, let’s consider the following piece of code:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Program
{
    static void Main(string[] args)
    {
        const int COUNT = 100000;
        HashSet<int> hashSetOfInts = new HashSet<int>();
        Stopwatch stopWatch = new Stopwatch();
        for (int i = 0; i < COUNT; i++)
        {
            hashSetOfInts.Add(i);
        }
        stopWatch.Start();
        for (int i = 0; i < COUNT; i++)
        {
            hashSetOfInts.Contains(i);
        }
        stopWatch.Stop();
        Console.WriteLine(stopWatch.Elapsed);
        stopWatch.Reset();
        List<int> listOfInts = new List<int>();
        for (int i = 0; i < COUNT; i++)
        {
            listOfInts.Add(i);
        }
        stopWatch.Start();
        for (int i = 0; i < COUNT; i++)
        {
            listOfInts.Contains(i);
        }
        stopWatch.Stop();
        Console.WriteLine(stopWatch.Elapsed);
        Console.Read();
    }
}

After executing it you will see the difference:
100000 ‘Contains’ operations using HashSet: 0.002 sec
100000 ‘Contains’ operations using List: 28.74 sec

Of course HashSets or SortedSets are not golden means for every possible scenario.HashSet should be used in case when you care about the performance (especially if you know that you will operate on a large set of items) but do not care about the order.SortedSet is a bit slower than HashSet but will give you a sorted collection and is much faster than List.

Use List when you want to iterate through the collection. Iterating through all the items in a List it is generally much faster than through a set (unless you use inside such methods as Contains).

If you know any other thing that C# developers should or should not do feel free to share it with us and leave a comment below!

Top 9 qualities of clean code

Clean Code

How often do you express your disbelief when browsing through someone’s code saying out loud “Omg, that’s real spaghetti code…” ? Probably quite often. And how sure are you that no one thought the same when working with your code? In other words, how sure are you that your code is clean? The truth is that you can only be sure if you fully know what clean code means.

 

It is hard to create a precise definition of clean code and probably there are as many definitions as developers. However, some principles that lead to a basic level of clean code apply. I have gathered the 9 most relevant ones and described them in short below.

1. Bad code does too much – Clean code is focused

Each class, method or any other entity should remain undisturbed. It should conform to SRP (Single Responsibility Principle). Shortly speaking, we can say that SRP (according to some well-known definitions) is about making sure that if you can think of the reason for changing a class you should not be able to come up with more than one.

Though, I wouldn’t limit this definition only to the concept of classes. In his latest articleRalf Westphal presents a broader definition of Single Responsibility Principle. According to his definition:

A functional unit on a given level of abstraction should only be responsible for a single aspect of a system’s requirements. An aspect of requirements is a trait or property of requirements, which can change independently of other aspects.

If you would like to read more about the quoted thesis I advise you to dig into his article.

2.  The language you wrote your code with should look like it was made for the problem

It is not the language that makes a program look simple, but the programmer who makes the language appear simple.

(quote from Robert C. Martin)

This means, for instance, that you shouldn’t use workarounds which make code and language usually look awkward. If you claim that something can only be done by means of a workaround, it usually means that you haven’t spent enough time on trying to find a good, clean solution.

3. It should not be redundant

It should comply with the DRY rule (Don’t Repeat Yourself). When the DRY principle has successfully been applied, the modification of any single element of a system doesn’t require a change in any other logically unrelated elements.

4. Reading your code should be pleasant

When  browsing through the code you should feel like reading Harry Potter (yeah I know that’s a slight exaggeration :)). You should feel that it was made to be read by any developer easily without hours spent on digging into it.

To achieve this you should try to comply with the KISS principle (Keep It Simple, Stupid!) and YAGNI principle (You Ain’t Gonna Need It). The KISS principle states that most systems work best if they are kept simple rather than made complex.

Therefore, simplicity should be a key goal in design, and unnecessary complexity should be avoided. YAGNI is a practice encouraging to purely focus on the simplest things that make your software work.

5. Can be easily extended by any other developer

You don’t write code for yourself , or worse -  for a compiler. You write code for other developers. Don’t be selfish – think about the others. Don’t torture other developers by producing a hardly maintainable and extendable code. Besides, in some months time you could be that “other developer” yourself.

6. It should have minimal dependencies

The more dependencies it has, the harder it is to maintain and change it in the future. You can always help yourself in achieving the goal of having minimal dependencies by using e.g.NDEPEND for checking potential incorrectness in the dependencies of your code.

7. Smaller is better

Code should be minimal. Both classes and methods should be short, preferably just a few lines of code. It should be well divided (also within one class). The better you divide your code the easier it becomes to read it. This principle might positively influence point 4 – it will make it easier for other developers to understand your code.

8. It should have unit and acceptance tests

How can we know that our code complies with the requirements if we don’t write tests? How can we maintain and extend it without the fear that it will stop working? Code without tests is simply not clean. If you would like to get to know more about the pillars of unit testing I advise you to read a very nice article Three Pillars of Unit Tests written by one of my colleagues.

9. It should be expressive

Expressiveness of the code means that it has meaningful names. These names should express their intention. They should not mislead you. They should be distinctive. Expressiveness makes code document itself making the need for documentation less important. If you want to read more about the subject of self-documenting code I recommend you to go through this article.

So what is in fact the definition of clean code?

All in all there is one final quality that summarizes all the above:

Clean code is a code that is written by someone who cares

quote from Michael Feathers

It is written by someone who has treated it as an art and paid attention to all details.

The subject of clean code is in fact very complex and goes far beyond the knowledge presented in this post. Therefore if you find any other characteristics that you think make code cleaner do not hesitate and share them with us!

9 Ways Your Brand New ASP.NET MVC Project Can Be Better

So you’re ready to start that new and ambitious ASP.NET MVC project. Maybe you’re kicking off a new startup or just finally moving that old-and-crusty webforms project into modern development world. Either way, here are a few very simple things you can do immediately after creating that new MVC project that you will thank yourself for as your project grows in complexity.
1. First of all, even MVC 3 has old-and-crusty aspects lurking in its projects. There are old MicrosoftMvc*.js AJAX and validation libraries that have be replaced with new jQuery hotness. These *.js files aren’t used so just delete them.
2. Many of the dependencies of your MVC project are out-of-date as soon as you create your project. You have an old version of jQuery, Entity Framework, etc. Luckily Phil Haackand crew had the brilliant insight to link these to NuGet. So the next thing you do is just run NuGet and choose the Updates tab.
What’s that, you don’t have NuGet? Oh, you need to fix that right now!
Here’s what you can expect under the NuGet updates page:
3. Speaking of NuGet, by default all the external, NuGet-based JavaScript files get mixed in with your few JS files you always need to go back to for editing. So this is what you do:
Create a separate folder called js and put your JavaScript files in there.
Don’t forget to import site.js into your _Layout.cshtml file.
4. You like intellisense, yes? You also like fast-loading pages yes? So on one hand, you want to use jquery-1.7.1-vsdoc.js for intellisense, but you want jquery-1.7.1.min.js for performance. Here’s what you do. Import the minified version into your layout page (see later in the article) but add a “reference” to the vsdoc version in your site.js file. See the /// <reference> at the top? See intellisense? Good!
BTW, you are using namespaces or the prototype pattern or something besides just importing junk into the global namespace aren’t you? I thought so.
5. Next, unless you are planning on using jQueryUI you should remove it via NuGet. It has so many files under the content folder that unless you plan on using it. They are just mental weight. Everything in your project should earn its keep. You can always add jQuery UI back via NuGet if you want it.
6. Web programming is awesome, except when it’s not. That usual happens when you find your page looks different in IE vs Chrome vs Safari. You can avoid some of these issuesjust by referencing Eric Meyer’s reset.css. Be sure to put reset.css as the *very* first CSS file.
7. In ASP.NET MVC, there are models, then there are models. In MVC, there are domain models that are usually UI independent. Then there are models specifically meant to be tied to views. These view-oriented models are called View Models. I recommend you put view models in their own folder to make this dead-obvious.
Stephen Walther has more on View Models if this is the first you’re hearing of them.
8. You said you like fast pages before right? Well MVC is “doing it wrong” in order to allow you to inline JS which you should not do. Put the JS imports at the bottom of the page.
Be careful though, modernizr.js needs to stay at the top to work.
9. There are times you need to conditionally import JavaScript files from pages. The technique above in #8 makes this adhoc importing difficult. We can easily fix this by adding a layout section called AdditionalJsImports and make it optional (see above). This lets pages add more JS *after* jQuery.js and site.js.
Conclusion
If you do these 9 things at the start of your project, you’ll be on a good path to a well-architected system with some key advantages: It doesn’t have files in the wrong places, it doesn’t have unused or outdated files, and it is built for performance.
Hope you find these tips useful! If you have your own, please add them to the comments below.

Add Hot Keys to Web Apps With jQuery.hotKeyMap.js

Hot keys (or accelerator keys) have been an important navigational tool for desktop applications for many years. Finally, web applications are adopting this functionality too. Check out this simple example of a web app with hotkeys.
Expect a more general blog post on the topic soon. For now, I’d like to share my jQuery plugin that enables this capability with you.
Announcing jQuery.hotKeyMap.js: A jQuery plugin that allows you to add complex hot-key functionality and navigation to your web apps with very little effort.
You can download it here:
It’s built on top of John Resig’s jQuery.hotKeys. His plugin is great (as you’d expect), but as far as I know doesn’t support complex series of keys. For example, if you want to GMail style navigation (press ‘g’ then press ‘t’ to go to sent mail), that’s fairly difficult using his plugin. Here’s how you accomplish this with my plugin:
In the code above, we’re assigning three immediate key actions (e.g. ctrl+z executes undo). We are also adding one complex sequence: g, h => navigates to the home page (calls navTo, not shown, passing ‘h’).
Want to see it in action? Check out my sample application:
It even comes with Visual Studio intellisense:
I hope you find it useful!

Difference between an Interface and Abstract class

Interface

An interface is a contract: the guy writing the interface say “hey, I accept things looking that way“, and the guy using the interface says “OK, the class I write looks that way“.
An interface is an empty shell, there are only the signatures (name / params / return type) of the methods. The methods do not contain anything. The interface can’t do anything. It’s just a pattern.
E.G (pseudo code):
// I say all motor vehicles should look like that :
interface MotorVehicle
{
    void run();

    int getFuel();
}

// my team mate complies and write vehicle looking that way
class Car implements MotoVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }

    int getFuel()
    {
        return this.fuel;
    }
}
Implementing an interface consume very little CPU, because it’s not a class, just a bunch of names, and therefor there is no expensive lookup to do. It’s great when it matters such as in embedded devices.

Abstract classes

Abstract classes, unlike interfaces, are classes. There are more expensive to use because there is a lookup to do when you inherit from them.
Abstract classes look a lot like interfaces, but they have something more : you can define a behavior for them. It’s more about a guy saying “these classes should look like that, and they got that in common, so fill in the blanks !”.
e.g:
// I say all motor vehicles should look like that :
abstract class MotorVehicle
{

    int fuel;

    // they ALL have fuel, so why let others implement that ?
    // let's make it for everybody
    int getFuel()
    {
         return this.fuel;
    }

    // that can be very different, force them to provide their
    // implementation
    abstract void run();

}

// my team mate complies and write vehicle looking that way
class Car extends MotorVehicule
{
    void run()
    {
        print("Wrroooooooom");
    }
}

Implementation

While abstract classes and interface are supposed to be different concepts, the implementation make that statement sometimes untrue. Sometime, there are not even what you think it is.
In Java, this rule is strongly enforced, while in PHP, interfaces are abstract classes with no method declared.
In Python, abstract classes are more a programming trick you can get from the ABC module and is actually using metaclasses, and therefor classes. And interfaces are more related to duck typing in this langage and it’s a mix between conventions and special methods call descriptors (the __method__ methods).
As usual with programing, there is theory, practice, and practice in another language :-)