RSS

Customized Form Buttons using simple CSS


CSS:

input[type=button], input[type=reset], input[type=submit], button {
background-color: #EFEFEF;
border: 1px solid #A0A0A0;
border-radius: 3px 3px 3px 3px;
font: bold 9pt Arial;
margin: 2px;
padding: 3px 9px;
cursor: pointer;
outline: none;
}

input[type=button]:hover, input[type=reset]:hover, input[type=submit]:hover, button:hover {
border-color: #2B2B2B;
}

input[type=button]::-moz-focus-inner, input[type=reset]::-moz-focus-inner, input[type=submit]::-moz-focus-inner, button::-moz-focus-inner {
border: 0;
}

buttons

 
Leave a comment

Posted by on April 10, 2013 in Uncategorized

 

Simple CSS/HTML: Create a glowing border around an Input Field like Twitter/GitHub


input {
    border:2px solid #dadada;
    border-radius:7px;
    font-size:20px;
    padding:5px; 
}

input:focus { 
    outline:none;
    border-color:#9ecaed;
    box-shadow:0 0 10px #9ecaed;
}v33Wq
 
Leave a comment

Posted by on April 10, 2013 in Uncategorized

 
Link

How to run Temple Run 2 Hack on Android:

1. Download the File from the Link above & copy the file

Link : Hack Temple Run 2 cheat # 1000+ million Coins & Gems

2. Go to the following path from android phone:

android/data/com.imangi.templerun2/files

3. Paste the file
4. Turn on the game & see magic :D

PS: You need to fill in a short survey inorder to download the file ‘gamedata.txt’

 
Leave a comment

Posted by on February 11, 2013 in Uncategorized

 

Tags: , ,

Technical Paper on 3D GIS TIN Modelling


Hi guys,

During my final year , I had taken up a project at Bhugol GIS Pvt.Ltd – IIT Bombay.

The Product -GRAM++ is a smart way to generate real time 3D Geographical Maps from spatial

data or vector points. The skills involved coming up with a innovative Algorithm based on Delaunay’s

Triangulation Principle to construct optimised Triangulated structures. Along with it the programming

required good hands on VC++ and Open-GL for graphics.

While developing the code I thought about having a proper technical documentation of the

entire algorithm parameters. This paper I have presented at a IEEE- Inter-College Competition which fetched me and my co-author Vimarsh Karbhari a dear friend  1st place.

You can download our paper : 3D GIS Modelling

 
Leave a comment

Posted by on September 27, 2012 in Uncategorized

 

Tags: , ,

Why I love working at a start up over a corporate job !


Sure, a corporate gig might (initially) pay more than a startup and come with cushy benefits, but there are real, career-defining reasons to heed the siren song of a startup.

You’ve graduated from college, diploma in hand (or in the mail), and you have a couple of job offers on the table. Other than being one of the lucky graduates in a weak economy, you have a choice to make. On one hand is a high-paying entry level position at a reputable brand in your field. On the other hand is a job offer from a small startup that is just kicking off. You’ve seen their product, believe in their mission, and like their approach, but aren’t sure you want to take on the risk of working at a startup. You’re leaning toward that corporate job and good pay with nice benefits. The smart choice.

Or is it?

Here are 7 reasons why you should take the plunge and enter the startup world instead.

1. You’ll have more responsibility. 

Working at a startup probably means you’re part of a small team, most likely in the single digits. Because of the nature of having such a small team, there is probably nobody else in the company who has the same skillset as you, approaches problems in the same way you do, or even thinks the same way you do.

When I joined Germinait Solutions (http://www.germin8.com/), the core team was pretty much already in place. Getting yourself into the transition from a chilled out college graduate to a working man with responsibilities is the only area you need to adapt yourself to and that gradually develops as you work towards the goals and tasks assigned to you.

2. You’ll be given more opportunities to explore. 

When I first started at Germinait, all I had to my developer name were a few projects/freelance work here and there. One year on, and I’ve had a host of skill-set involving front end technologies. Other than being only a UI developer, I have had opportunities to work on domain and expertise beyond my scripting knowledge and have added core java programming too to my technology stack.I feel as a complete developer and not only a UI scripter. I know that if I would have sought out a smaller position at a higher-paying and recognizable Fortune 500 company I would still be working  on a small piece of code through the slush pile of maintainance work. No thanks.

3. You’ll be able to do a lot of different things and not be stagnant. 

One of the biggest complaints I hear from peers who have entered into a more-structured, corporate position is that they are generally stuck with their main task and don’t get to branch out into other areas. This is simply not done with a start up.

4. You will get true innovation skills. 

People who start their own business have a different mental and professional makeup than those who have never gone off to create something of their own. Entrepreneurs are defined by seeing a problem and thinking of an innovative and original way of addressing it Innovation is more than creativity. It’s action and reaction, solving problems in a new, enlightening way. Every successful startup has true innovators, and if you find the right ones, you’ll learn plenty.

5. Your work will be noticed.

If I’ve learned anything from watching TV shows and movies, it’s that if you work at a big company, chances are that all of your hard work is going to be ignored by the boss or someone else is going to snag the credit. But at a startup, it’s nearly impossible not to notice a job well done or to give credit where credit is due. If you succeed, the small team will recognize it instantly, and the praise and glory is yours to bask in. Spread your arms in glory, my friend, your work has been recognized. On the flip side of that coin is that it’s also really easy to see when you’ve screwed up. For two reasons, this is a good thing.

1. The first is that it’s nearly impossible to slack off to. Within a few days, your coasting and slacking will be noticed and the rest of the team will wonder why they are working harder than they have to. That keeps you focused and on your game.

2. The second reason is that because failure is easier to notice, you’ll make sure to eliminate mistakes in order to avoid disappointing your colleagues.

6. No Boring office life.

Let me count the ways:

  • I wear jeans to work. In the summer, I wear shorts and sandals.
  • If there isn’t at least one really good joke in an hour, it’s probably a slow day.
  • Everyone else who works at a startup has the same drive and excitement for creation as you do.

7. You’ll learn to be cost-conscious. 

Working at startup probably means that money is tight.  You’ll find happiness in being part of a team that is trying to make other people’s lives easier, more fun, and more manageable. Your entire life will take on a meaning of creation, and you’ll be more energized, both physically and mentally, to take on new hobbies and start your own personal projects. In the startup world, it’s all about creating more and consuming less (this does not apply to delicious food or DoNuts).

 

 
Leave a comment

Posted by on September 19, 2012 in Uncategorized

 

Java API – Intro for a Beginner


Java API  is not but a set of classes and interfaces that comes with the JDK. Java API is actually a huge collection of library routines that performs basic programming tasks such as looping, displaying GUI form etc.

 

Java API

      

What is Java API?

Java API is not but a set of classes and interfaces that comes with the JDK. Java API is actually a huge collection of library routines that performs basic programming tasks such as looping, displaying GUI form etc.

In the Java API classes and interfaces are packaged in packages. All these classes are written in Java programming language and runs on the JVM. Java classes are platform independent but JVM is not platform independent. You will find different downloads for each OS.

The Java comprises three components:

  • Java Language
  • JVM or Java Virtual Machine and
  • The Java API (Java programming interface)

The Java language defines easy to learn syntax and semantics for Java programming language. Every programmer must understand these syntax and semantics to write program in Java language.

Type of Java API :

There are three types of API available in Java Technology.

  • Official Java Core API
    The official core API is part of JDK download. The three editions of the Java programming language are Java SE, Java ME and Java EE.
      
  • Optional Java API
    The optional Java API can be downloaded separately. The specification of the API is defined according to the JSR request.
     
  • Unofficial APIs
    These API’s are developed by third parties and can downloaded from the owner website.

Official Java Core API list

Name Acronym Package(s) that contain the API Description and Version History
Abstract Window Toolkit AWT java.awt First released with version 1.0.
Swing   javax.swing Included in J2SE 1.2 and later.
Accessibility   javax.accessibility  
Drag n Drop   java.awt.datatransfer 
java.awt.dnd
 
Image I/O   javax.imageio 
javax.imageio.*
 
Sound   javax.sound.midi 
javax.sound.midi.spi 
javax.sound.sampled 
javax.sound.sampled.spi 
 
Java Database Connectivity JDBC java.sql 
javax.sql 
 
Java Cryptography Extension JCE javax.crypto 
javax.crypto.interfaces 
javax.crypto.spec
Included as part of J2SE 1.4 and later. Available as an optional package to versions 1.2 and 1.3.
Java Authentication and Authorization Service JAAS javax.security.auth Included in J2SE 1.4 and later, previously released as an optional package with version 1.3.
Java Secure Socket Extension JSSE javax.net 
javax.net.ssl 
java.security.cert 
A set of packages that enable secure Internet communications. Included as part of J2SE 1.4 and later, JSSE 1.0.3 is an optional package to the Java 2 SDK, versions 1.2 and 1.3.
Java Native Interface JNI   Allows Java code running in the Java virtual machine (JVM) to call and be called[1] by native applications (programs specific to a hardware and operating system platform) and libraries written in other languages, such as C, C++ and assembly.

Optional Java API list

Name Acronym Description and Version History Available from
Java Advanced Imaging JAI An API which provides a set of interfaces that support a high-level programming model allowing to manipulate images easily.  
Java Communications API JCA    
Java Data Objects JDO A specification of Java object persistence .  
JavaHelp   A full-featured, extensible help system that enables you to incorporate online help in applets, components, applications, operating systems, and devices.  
Java Management Extensions JMX A technology that supplies tools for managing and monitoring applications , system objects, devices (e.g. printers ) and service oriented networks.  
Java Media Framework JMF An API that enables audio, video and other time-based media to be added to Java applications and applets.  
Java Naming and Directory Interface JNDI An API for directory services .  
Java Speech API JSAPI This API allows for speech synthesis  
Java 3D J3D A scene graph -based 3D API. available here
Java OpenGL JOGL A wrapper library for OpenGL . available here

Important Java API

As a programmer you must learn about the following important java APIs.

 
Leave a comment

Posted by on July 24, 2012 in Uncategorized

 

Tags: , ,

Six tips for protecting your e-mail privacy


Sending an email message is certainly more private than posting on a social networking site, but email has its own dangers. Here are six tips to help you communicate without risking your privacy.

By now we all know not to post sensitive information on social networking sites. Even with privacy settings enabled, that angry political rant or embarrassing beach photo can easily become the next viral Internet sensation. By comparison, email seems like a much safer communications medium, but you can still get into trouble if you lose control of your account. In addition, email messages bounce unprotected from server to server, so private information might be compromised. Here are six tips to protect your email account and your private messages.

1. Use a Strong Password. You give out your email address all the time; it’s not really private information. That being the case, the only thing protecting your account from misuse is the password. A malefactor who guesses your too-weak password gains full control of your email account. Protect your account with a strong password, especially if you use a Web-based email provider like Gmail or Yahoo mail.

2. Beware Public PCs. If you check your email on a public computer in a library or Internet café, be absolutely sure you’ve logged out before leaving. Even then, you might be leaving behind traces that could give the next user too much information about you. Follow PCMag’s advice toUse Public Computers Safely.

3. Protect Your Address. It’s true that you give out your email address every time you send a message, but there’s no need to give it to the whole world. Don’t include your email address in comments on blog posts, or in social media posts. Spammers and scammers scrape pages all the time looking for new victims.

4. Lock It Up. If you step away from your desk, lock the Windows desktop or close your email client. Otherwise a sneaky co-worker could read your mail or even reset your login password. Hold the Windows key and press L to lock the desktop instantly.

5. Don’t Be Fooled. Oh, dear. Your email provider has sent you notification of a security breach, with a link to reset your password. Don’t click that link! It’s almost certainly a fraud, designed to steal your email account password. If you have any doubts, navigate to the email provider’s site directly and double-check.

6. Use Encryption. Sometimes you just have to send sensitive information by email. To keep your data safe, save it as a document and use your word processing application’s built-in encryption, or store the document in an encrypted ZIP file. Then share the password with the recipient separately. If you need encryption frequently, try a free email encryption product likePrivateSky or Enlocked.

Does implementing these tips seem like too much trouble? That’s nothing compared to the trouble you’ll face when you log on one morning and find that your email account just sent a million advertisements for “gentleman’s enhancement” products. A little effort now can head off big problems later.

 
1 Comment

Posted by on May 20, 2012 in Uncategorized

 

Tags: , , ,

Acegi – Security Framework for Java Applications


Almost by its very nature, one of the most tedious and difficult aspects of application development is security, specifically authentication and authorization. Most multi-user applications need to confirm that a user is whom he says and then has appropriate authorized access to the necessary resources. Therefore, security is often one of the most important aspects. The collision of these factors has the impact of making security forgetful, error prone, and potentially dangerous, especially for enterprise applications.

While the J2EE specification and JAAS, the Java Authorization and Authentication Service, provide a step in the right direction, they are far from complete. Every application server vendor is free to implement container security differently nor are they required to use JAAS. This leads to portability and user management constraints. Furthermore, it still does not approach security in the manner as described above- as an aspect.

Enter the Acegi Security framework, an open source security framework designed for Spring. Created by Ben Alex, the framework has begun to gather a loyal following for its comprehensive list of features, excellent unit test coverage, ease of use, and loosely coupled integration with Spring. While the framework was purposely designed for Spring, there is no reason it could not be used with non-Spring applications, especially web applications.

An introduction to Acegi, its core components, and configuration via Spring’s application context. With this knowledge, we will learn how to implement authentication and authorization services for a simple web application.

Authentication

Before deciding to grant or deny access to a resource, the user must provide the appropriate security identification. For this reason, Acegi provides two key interfaces for providing authentication services — Authentication and AuthenticationManager. Let’s examine each of these to find out how they form a complete authentication system.

The Authentication interface which holds three important objects. The first object is the principal, which identifies the caller (user). The second object are the credentials that provide proof of the identity of the caller. For traditional logins, this is the username’s respective password. The final object contained by the Authentication interface is and array of the authorities granted to the principal.

During the authentication process, an implementation of the Authentication interface is populated with the principal and credentials by client code. For example, a web application presents the user with a prompt for username and password. The supplied username and password are then used to create the Authentication object. Yet, that still leaves one of the three contained objects empty, the array of granted authorities. Here is where the AuthenticationManager plays its role in the authentication chain.

AuthenticationManager specifies a single method, authenticate.

public Authentication authenticate(Authentication authentication) throws AuthenticationException;

This method takes the two-thirds populated Authentication object as a parameter. From there, the method has two options, either return a fully populated Authentication object or throw an AuthenticationException. If the correct principal and credentials were provided, theAuthenticationManager does the former by returning a fully populated Authentication object. It supplements it by populating the authorities granted to the authenticated principal. Should authentication fail, an AuthenticationException is thrown that represents the reason why via a number of subclasses.

The most important subclasses are BadCredentialsException, DisabledException, and LockedException. As one would imagine, the first is thrown when an incorrect principal and credentials are provided. The other two are thrown when the principal account is either disabled or locked out, respectively. Therefore, the credentials were not checked and authorization has been denied.

Authentication Providers

While the above interfaces are important, especially to developers creating custom authentication mechanisms for Acegi, the primary value for most is an understanding of the authentication chain. Most developers should consider using one of the provider-based authentication packages included. The most popular implementation of the AuthenticationManagers is the ProviderManager.

For all practical purposes, the ProviderManager is nothing more than a wrapper around a list of one or more AuthenticationProvidersprovided to the class. During authentication, the wrapper class cycles through the list of AuthenticationProviders until a compatible provider is located. Once located, the authenticate method of the AuthenticationManager delegates to that specific provider. In response, the provider either returns the fully populated Authentication object or throws an AuthenticationException. As expected, the cumulative result of all providers is returned from the wrapper (ProviderManager).

Several AuthenticationProviders implementations are provided with the Acegi Security System, including those for JAAS and JBoss authentication. For this article, we will be using the DaoAuthenticationProvider, which is able to authenticate a username and password combination against a repository, such as a database or in-memory hash. This provider is easy to understand, configure, and demonstrate. However, readers should examine the other providers to determine the one that suits their needs best.

With each level of abstraction and delegation comes flexibility. In the case of the DaoAuthenticationProvider, it delegates to an implementation of the AuthenticationDao interface, which has a single method, loadUserByUsername. This method that takes a username and loads the respective user details to verify for authentication by InMemoryDaoImpl Developers are free to create their own implementation, for example, using Hibernate; however, Acegi ships with two very usefully implementations, a JDBC-based and memory-based. For simplicity, this article will use the latter, InMemoryDaoImpl.

Enough with the explanation and abstraction, let’s begin by configuring the aforementioned components starting with theAuthenticationDao. (This article assumes the user is vaguely familiar with Spring XML configuration.) The configuration below creates an instance of the InMemoryDaoImpl with a user named “matthew”. This user has a password of “contegix” and a granted authority of “ROLE_ADMIN”.

applicationContext.xml

<bean id="memoryAuthenticationDao">
    <property name="userMap">
        <value>
            matthew=contegix,ROLE_ADMIN
        </value>
    </property>
</bean>

Excellent. The next step is to create an instance of the InMemoryDaoImpl with the memory authentication DAO listed as a provider.

applicationContext.xml

<bean id="daoAuthenticationProvider">
     <property name="authenticationDao">
         <ref local="memoryAuthenticationDao"/>
     </property>
</bean>

Finally, let’s take the next step up and create the authentication managers with the DAO authentication provider as the sole provider.

applicationContext.xml

<bean id="authenticationManager">
    <property name="providers">
        <list>
            <ref bean="daoAuthenticationProvider"/>
        </list>
    </property>
</bean>

At this point, the authentication manager is fully configured and ready for use. The next step is to tie this into our fictional web application.

There are a number of ways to perform authentication for web applications. The most prevalent are Basic Authentication as defined by RFC 1945, Section 11 and pure HTTP Session Authentication. For our fictional application, we will use the latter.

Acegi performs HTTP session authentication through the use of a servlet filter. The filter, AuthenticationProcessingFilter, processes information from a programmed login form containing two parameters — j_username and j_password. One unique aspect of the Acegi authentication filter is the fact that it delegates to a bean proxy defined in Spring’s application context using FilterToBeanProxy. Therefore, all Acegi filters will be configured using as an instance of this class and must be provided either a targetClass or targetBean via an initialization parameter that points to the bean in the application context. The application context bean is configured with the parameters for authentication rather than the filter.

web.xml

<filter>
    <filter-name>Acegi Authentication Processing Filter</filter-name>
    <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>
    <init-param>
        <param-name>targetClass</param-name>
        <param-value>
        net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter
        </param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>Acegi Authentication Processing Filter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

applicationContext.xml

<bean id="authenticationProcessingFilter">
    <property name="authenticationManager">
        <ref bean="authenticationManager"/>
    </property>
    <property name="authenticationFailureUrl">
        <value>/login.jsp?error=1</value>
    </property>
    <property  name="defaultTargetUrl">
        <value>/</value>
    </property>
    <property name="filterProcessesUrl">
        <value>/j_acegi_security_check</value>
    </property>
</bean>

Let’s look at the properties passed in the AuthenticationProcessingFilter bean. The first property is relatively self-explanatory. It is a reference to the configured authentication manager. Obviously, the bean will utilize this to proceed through the authentication chain.

If authentication fails, the browser will automatically be redirected to the URL specified by authenticationFailureUrl. If authentication is successful, the browser will be redirected to the protected URL that forced the authentication. This allows the user to be automatically returned to what he was trying to access. If no resource was specified, for example when the user directly accesses the login URL, thedefaultTargetUrl property specifies where the user will be redirected.

Finally, the filterProcessesUrl is the URL by which this filter will be activated. For the developer, this URL should be specified as the action parameter in the HTML form.

Now that our fictional application can authenticate users, let’s begin placing access constraints on resources.

Authorization

The concept of Security Interception is key to protecting resources under Acegi. Prior to access to the resource, interception determines whether or not the resource should be protected. If so, interception examines who made the call (the principal) and whether or not access should be granted. Based upon the result, the interceptor either allows the request or not. Let’s examine in-depth how this process occurs.

Tracing the chain of authorization, the security interceptor receives access to a protected resource. Assuming the user is authenticated, it delegates to an implementation of the AccessDecisionManager, which receives key parameters such as the authenticated Authentication object and resource properties, among others. The final decision for access is left in the hands of theAccessDecisionManager.

While developers are welcome to implement a custom AccessDecisionManager when appropriate, most circumstances allow for use of the implementations that are based upon the concept of voting. Acegi currently ships with three implementations of AccessDecisionManagerthat tally votes — ConsensusBased, UnanimousBased, and AffirmativeBased. The ConsensusBased implementation grants or denies access based upon the consensus of non-abstain votes. As the name suggests, the UnanimousBased implementation requires unanimous consent in order to grant access but does ignore abstains. Finally, the AffirmativeBased implementation grants access if at least one access granted is received while deny votes are disregarded.

The question that should come to mind is how does a voting AccessDecisionManager determine which way to cast a vote. Here is whereAccessDecisionVoters play a role in the authorization decision chain. The sole shipping implementation of this interface is the RoleVoter, which grants access if the principal has been assigned the role. Role assignments are the elements of its granted authority array of the respective authenticated Authentication object. In other words, if a resource requires a role of SUPERVISOR, the user will be granted access if it is listed as one of its granted authorities when he authenticated.

For the case of our fictional application, the UnanimousBased implementation with the RoleVoter will suffice for our minimalist needs; however, it is truly important to understand the complex structure and role of AccessDecisionManagers in Acegi. Please consult the reference documentation to learn more.

Let’s configure the authorization system by crawling back up the chain, starting with the RoleVoter and UnanimousBased.

applicationContext.xml

<bean id="roleVoter"/>

<bean id="accessDecisionManager">
    <property name="allowIfAllAbstainDecisions">
        <value>false</value>
    </property>
    <property name="decisionVoters">
        <list>
           <ref local="roleVoter"/>
        </list>
    </property>
</bean>

The RoleVoter exists as a simple bean instantiation with no properties. The UnanimousBased has two properties configured. The first one determines whether or not access should be granted if all AccessDecisionVoters abstain. The second is a reference to the instantiatedRoleVoter.

The next step is to configure the security interception system. In the case of web applications, security interception is done using a servlet filter – SecurityEnforcementFilter — in combination with the FilterSecurityInterceptor. These two objects work in conjunction to provide authorization access decisions for URL-based resource. For the most part, the filter handles session management and URL redirection for user login (as specified by an AuthenticationEntryPoint object) while delegating to the interceptor for security decisions.

As before, the filter utilizes the FilterToBeanProxy class to retrieve an instantiated bean from the application context.

web.xml

<filter>
    <filter-name>Acegi HTTP Request Security Filter</filter-name>>
    <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class>

    <init-param>
        <param-name>targetClass</param-name>
        <param-value>
        net.sf.acegisecurity.intercept.web.SecurityEnforcementFilter
        </param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>Acegi HTTP Request Security Filter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

applicationContext.xml

<bean id="securityEnforcementFilter">
    <property name="filterSecurityInterceptor">
        <ref bean="filterInvocationInterceptor"/>
    </property>
    <property name="authenticationEntryPoint">
        <ref bean="authenticationEntryPoint"/>
    </property>
</bean>

<bean id="authenticationEntryPoint">
    <property name="loginFormUrl">
        <value>/login.jsp</value>
    </property>
</bean>

<bean id="filterInvocationInterceptor">
    <property name="authenticationManager">
        <ref bean="authenticationManager"/></property>
    <property name="accessDecisionManager">
        <ref bean="accessDecisionManager"/></property>
    <property name="objectDefinitionSource">
        <value>
            CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
           PATTERN_TYPE_APACHE_ANT
            /secure/super/**=ROLE_SUPERVISOR
            /secure/.* =ROLE_USER,ROLE_SUPERVISOR
        </value>
    </property>
</bean>

Starting from the bottom, a FilterSecurityInterceptor is declared and passed both the authentication manager and the access decision manager. Furthermore, the object receives a set ObjectDefintionSources. Each value provides specific meanings. The first value informs the interceptor to convert all URLs to lowercase before evaluating. PATTERN_TYPE_APACHE_ANT is an instruction detailing the format of the final two values. It tells the interceptor to examine the remaining parameters using Apache Ant style pattern matching rather than the default pattern matching using regex. (This is a personal preference of the author and is not required.)

The final two values are URL patterns to secure. The left-hand side of the equals is the URL pattern while the right-hand side details the roles necessary for casting a grant vote. In this example, anything under /secure/super/ will only be accessible by principals who have aSUPERVISOR role while /secure/ will be accessible to principals with either the USER or SUPERVISOR role.

The AuthenticationEntryPoint will be called if a user requests a protected URL when they are not authenticated. Finally, the targetClassbean is declared and passed the reference to the AuthenticationEntryPoint and the FilterSecurityInterceptor.

Voila! Our example application now has everything it needs to protect at least two URL resources based upon roles and perform authentication.

Conclusion

Acegi is one the best security framework available for the Java platform. Even though the configuration utilizes Spring, this article demonstrate the power of the system while showing there is no reason why it can not be used even when not integrating Spring into your application. Furthermore, the entire framework serves as an excellent example of extensibility through abstraction

 
Leave a comment

Posted by on May 19, 2012 in Uncategorized

 

Tags: , ,

jQuery vs MooTools – Which One Is The Best?


These two frameworks just aren’t trying to do the same things. They overlap in the functionality they provide, but they are not trying to do the same things

Opposite Directions

MooTools is aimed more at JavaScript developers, while jQuery is more for people who want to implement JavaScript functionality in the easiest possible way.

jQuery is for people who aren’t necessarily interested in delving deep into JavaScript while MooTools provides an object-oriented framework for hardcore JavaScript development. This is why most people find MooTools harder to use in comparison to jQuery.

jQuery makes working with the DOM easier. MooTools makes working with all of the JavaScript language – not just the DOM – easier.

Both are fantastic libraries/frameworks and I think the better question for you to ask is

Which one should I use for this project

This can be determined by circumstances beyond your control e.g. The project leadership has already selected a framework for you, or the application development framework you are developing on is already using one over the other – and you may wish to avoid bloating-up your application with multiple libraries and increasing load times (not to mention script conflicts).

Different Camps

Here’s an example of what the world’s most popular PHP content frameworks have chosen:

Drupal – jQuery
WordPress – jQuery
Joomla – MooTools

I work in each of these environments and I recommend to anyone doing the same to view jQuery and MooTools as tools – not competitors. You might simple prefer the one over the other, at the end of the day they are just JavaScript; and there’s a right one (tool) for the job at hand.

 
Leave a comment

Posted by on October 30, 2011 in Uncategorized

 

Power Of Social Media-Revolution.


Watch the Video and See For Yourself How Powerful,Lethal and Amazing is Social Media’s Impact in each one’s daily Life.

 

 
Leave a comment

Posted by on October 6, 2011 in Uncategorized

 
 
Create your own website, free on WordPress.com.Create your own website.
Start free