This is an absolute pleasure for the team Cresco Solution that the founders, Husen Daudi and Jay Vora have been framed into one of the Best Gujarati NewsPaper Divya Bhaskar.
They have been appreciated for their devotion towards homeland,country India and all their CSR activities they regularly do in order to make the society a happier place ever.
They always spread goodness and wellness around. They have learnt and spread the importance of ‘WE’ as they believe Unity is strength.
‘Alone I can only sing, together we can rock’ !
The article says:
” Youth in India has a tremendous set of abilities and its better to use the strength to empower own nation. These are the noble thoughts of 2 young men, Husen Daudi and Jay Vora who completed their Masters in Computer Application and Bachelors of Engineering from well-known institutes respectively and have always earned a great respect through the career.
They have a great devotion to their own country and this is what each countryman should have within. Today, they are counted as one of the best entrepreneurs of Gandhinagar. They have worked in an IT company located earlier in Ahmedabad and served the best and posted as top level management members.
Having a fact in mind that they can generate more employment, they left the job and started 2 ventures altogether called Serpent Consulting Services and Cresco Solution. Started with 2 employees themselves, within less than a year they have a great staff of 16 employees. They will officially complete a year in December 2012. Next month, they will get company into the label of Private Limited company.
Do Your Work Yourself
This is their belief and following this ethic, they always do their work themselves, they clean office themselves every month. Their staff is also so supportive that they also understand their responsibilities. And Hence, they have no post of peon in the office.
Mother-tongue is the best medium
There are a number of creative and innovative youngsters in India, but they really need motivation. They have got education from India and in their mother-tongue. The real give-back, thanksgiving is when Indian use their brain and energy for India. Having a supreme command over English, they add that if you have studies in mother-tongue, you think faster, become innovative and become fluent in English too.
Teaching with Business
Husen and Jay do not believe in only earning and gathering money, but believe in sharing the good and guide others to do more. They have started another venture called Cresco Solution where they teach and train IT students in international standard and also make them professional, give them interview/placement assistance and develop their personality so they can come out as a confident, strong and decent IT personnel. International students have also taken the advantage and share of their knowledge.
CSR : Corporate Social Responsibilities
They believe in ‘Rights and Duties‘ in a very balanced manner. They do various social activities like Blood donation camp, visiting old aged home, distributing sweets to needy people, distributing food and slippers to needy ones, etc. Husen and Jay themselves have donated blood number of times.”
We congratulate both of them and wish the whole Team a great going ahead. We also thank all the well-wishers.
Thanks,
Serpent Consulting Services & Cresco Solution.
More News here:
By now you’re probably aware that the good folks over at Canonical have been hard at work on Quantal Quetzal, the 12.10 release of the popular Ubuntu operating system. While dedicated users of the Linux-based platform will be well versed in the upcoming features and changes, you may be wondering what new additions have been made and whether or not it’s worth your while to upgrade from the LTS version for your daily driver. While the additions that come with Quantal aren’t earth-shattering in nature, they’re certainly intriguing enough to warrant a serious look at upgrading.
Under the hood, 12.10 will be shipping with some incremental upgrades, like the 3.5.4 Linux kernel which will be powering some Gnome 3.6 apps and libraries. While the full Gnome shell isn’t present in this build, it does still serve as the building blocks for the oft-maligned Unity interface. Whether you like it or not, Unity is here to stay as the major changes in the OS come not in the technical underpinnings, but in the way that the Unity Dash interacts with your digital content stored both locally and in the cloud.
Canonical has been taking a hard look at exactly how you and its other users have been interacting with different forms of content. If you’re like me, you have ten to fifteen different tabs open in your browser, each dialed into a different web-based service. Whether it be email, social media, or online entertainment it has become the norm for you to have most of your vital day-to-day information in the cloud.
This hasn’t gone by unnoticed by Canonical, as they have updated the Unity Dash to now search and browse content that might not be stored on your local hard drive. Built into Quantal Quetzal are several new API hooks that will search online storage services such as Google Drive like they are native to your local machine. The result being that when you type a search term into the Dash, your online documents and images will be included in the results list. In addition to Google Drive, you will be able to add your Flickr and Facebook account credentials to enrich your search capabilities for your online media.
As far as helping you to curb the amount of tabs you have to wrestle with in the browser, 12.10 now includes the ability to create an embedded desktop application out of your most-used web apps. Now instead of opening one browser tab to check your Gmail, then another to post to Facebook, and yet another to update your followers with a timely message on Twitter, you can now create clickable icons that work through Firefox to better manage your work area. Some will find this a bit redundant, but if you make use of the desktop management functionality to distribute these open windows across your work space it does become easier to locate each web app.
Mac users will find this functionality familiar as they have add access to an application for some time called Fluid that does the same thing, albeit not as a native part of OS X. When making the switch from Mac to a Windows desktop for my daily work machine, Fluid’s functionality was in my top three features that I desperately missed. Seeing Canonical make the move to include this a native part of the OS is a welcome addition.
The last bit of added functionality on the desktop side of things are the new lenses that Canonical as included to improve the visual information that is given to you when you search for certain things. For example when you are searching for music, Quantal Quetzal will now show you both free and paid options from Amazon and the Ubuntu One cloud music service. A feature that has received mixed reactions, but makes sense as a revenue stream for Canonical.
On the server side of things, Canonical continues to focus on tools that sysadmins will appreciate when comes to constructing and deploying new boxes. Building off its recent naming as a platinum OpenStack partner, the software company has included the Folsom OpenStack release with this build, as well as Cinder and Quantum. The former being a virtual networking API and the latter being provided for block storage services.
Probably the biggest news with this update of Ubuntu Server is the ability for sysadmins that value the stability of their existing 12.04 servers to have access to these new services. Using Ubuntu Cloud Archive, the latest release features can be back-ported to 12.04 without risk of destabilizing current deployments. Definitely a smart addition by the development team at Canonical.
Both Ubuntu Desktop and Server 12.10 are available to download from the Ubuntu site for new installs. Current users can upgrade using the terminal or software update mechanism built into the platform.
For more details about the 12.10 release, hit up the Quantal Quetzal documentation.
Courtesy : ExtremeTech
The Joomla Project is pleased to announce the immediate availability of Joomla 3.0.1. This is a security release. This release also fixes several high-priority problems with version 3.0.0.
IMPORTANT NOTE FOR 3.0.0 SITES: If you plan to update a site from 3.0.0 to 3.0.1, you need to install the Joomla 3.0.0 Hot Patch before doing the update to Joomla 3.0.1. See the Hot Patch Instructions for more information. This is NOT required for updating from version 2.5.x. If you require the FTP layer you will need to manually FTP the update. Also, please note that version 3.0 users need to make sure the Update server is set to “Short Term Support” in the Joomla! Update component. Otherwise, no 3.0.x updates will show.
The Production Leadership Team’s goal is to continue to provide regular, frequent updates to the Joomla community. Learn more about Joomla! development at the Developer Site.
Note: Please read the special update instructions before updating. Updating from 3.0.0 requires that you apply the hot patch first.
Want to test drive Joomla? Try the online demo or the Joomla JumpBox. Documentation is available for beginners.
Please note that you should always backup your site before upgrading.
Check the Joomla 3.0.1 Post-Release FAQs to see if there are important items and helpful hints discovered after the release.
Thanks to the Joomla Bug Squad for their dedicated efforts investigating reports, fixing problems, and applying patches to Joomla. If you find a bug in Joomla, please report it on the Joomla! CMS Issue Tracker.
Active members of the Joomla Bug Squad during the past three months include: Aaron Wood, Andrea Tarr, Bill Richardson, Brian Teeman, Christophe Demko, Dean Clarke, Dennis Hermacki, Elin Waring, Emerson Rocha Luiz, Harald Leithner, Itamar Elharar, Jacob Waisner, James Brice, Janich Rasmussen, Jean-Marie Simonet, Kevin Griffiths, Loyd Headrick, Marijke Stuivenberg, Marius van Rijnsoever, Mark Dexter, Matt Thomas, Michael Babker, Neil McNulty, Nicholas Dionysopoulos, Nick Savov, Nikolai Plath, Ofer Cohen, Peter Wiseman, rachmat wakjaer, Radek Suski, rob clayburn, Roland Dalmulder, Rouven Weßling, Rune Sjøen, Samuel Moffatt, Shaun Maunder, Soheil Novinfard, Troy Hall, Viet Vu.
Bug Squad Leadership: Mark Dexter, Coordinator.
A big thanks to the Joomla! Security Strike Team for their ongoing work to keep Joomla secure. Members include: Airton Torres, Alan Langford, Bill Richardson, Elin Waring, Gary Brooks, Jason Kendall, Jean-Marie Simonet, Jeremy Wilken, Marijke Stuivenberg, Mark Dexter, Michael Babker, Rouven Weßling, Samuel Moffatt.
The great news is you don’t have to be a developer to help build Joomla. The Joomla Bug Squad is one of the most active teams in the Joomla development process and is always looking for people (not just developers) that can help with sorting bug reports, coding patches and testing solutions. It’s a great way for increasing your working knowledge of Joomla, and also a great way to meet new people from all around the world.
If you are interested, please read about us on the Joomla Wiki and, if you wish to join, email the Bug Squad coordinator.
You can also help Joomla development by thanking those involved in the many areas of the process.
HTML5 has made her presence felt around the Internet since its launch.
HTML5 has been helping webmasters to clean up their code by utilising newly introduced features of the same. It won’t be possible for me to touch base with every HTML5 feature, but I will be listing down some of those during the course of this tutorial.
Forms are an integral part of any website that wants its visitors to get in touch with the owner of that website. They bridge the gap virtually between the webmaster and the website visitor.
Here, we will implement a very basic combination of HTML5 with CSS and PHP in order to create a contact form. You might have created a lot of contact forms but our purpose here is to do the same using the appreciable features of HTML5. Let’s do it!
Note: The code below will work with most of the Internet browsers that are being widely used as of today.
Our Goal
For starters, you must have an idea of what we are going to create. It will be a simple contact form as shown below:
Catching up with HTML5
Without further discussions, let’s create our first index.php file. Please be aware that you will require a web server to test index.php file. Explaining the setup of same is out of the scope of this tutorial.
The very initial index.php will look like this:
<!DOCTYPE HTML> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>My Contact Form</title> </head> <body> <header> <h1>My Contact Form</h1> </header> <section> [Form code goes here] </section> </body> </html>
See any differences from your regular html code?
Well, there are few. Let me explain each of them:
The Form:
Now, lets talk about the code that will shape our form (the very purpose of this tutorial). The below code will be placed in our section tag (unless you are planning to push your form to the header or footer section of your webpage.)
<form> <label>Your Name:</label> <input name="name" placeholder="Goes Here"> <label>Your Email:</label> <input name="email" type="email" placeholder="Goes Here"> <label>Your Message:</label> <textarea name="message" placeholder="Goes Here"></textarea> <input id="submit" name="submit" type="submit" value="Submit"> </form>
Again, you will notice differences between the above HTML5 code and our old versions. Let me throw some light:
Now, our very own CSS
That was it! Our HTML5 tutorial is over and we move on to CSS to style our HTML5 form. For starters, place the below code just above your <body> tag so as to tell your index.php that someone out their is ready to make her beautiful.
<link type="text/css" rel="stylesheet" href="style.css">
Now create a style.css in the same folder and paste the below code into it.
label { display:block; margin-top:50px; letter-spacing:1px; } /* This section centers our complete page */ .main { display:block; margin:0 auto; width:500px; } /* This section centers the form inside our web page*/ form { margin:0 auto; width:420px; } /* Applying styles to our text boxes */ input, textarea { width:400px; height:27px; background:#666666; border:2px solid #f6f6f6; padding:10px; margin-top:10px; font-size:0.7em; color:#ffffff; } textarea { height:200px; font-family:Arial; } #submit { width:85px; height:35px; background:url(submit.png); text-indent:-9999px; border:none; margin-top:20px; cursor:pointer; }
Let me deconstruct the important parts of above code:
PHP Integration
First, we edit the <form> tag in your code to what you see below:
<form method="post" action="index.php">
Now, insert the below code just above your <form> tag:
<?php $name = $_POST['name']; $email = $_POST['email']; $message = $_POST['message']; $from = 'From: My Contact Form'; $to = 'salman@mywebsite.com'; $subject = 'Wassup?'; $body = "From: $namen E-Mail: $emailn Message:n $message"; if ($_POST['submit']) { if (mail ($to, $subject, $body, $from)) { echo '<p>Message Sent Successfully!</p>'; } else { echo '<p>Ah! Try again, please?</p>'; } } ?>
Once you save the above changes then your contact form should work as expected. It will send emails to your email address (salman@mywebsite.com in our case.)
Courtesy: DeveloperDrive
Modern browsers like Internet Explorer 10 support CSS 3D and 2D Transforms and CSS Animations. By tapping the power of your GPU and running asynchronously from regular JavaScript, these technologies provide a more performant and flexible alternative to traditional script-based animations for Web content.
I’ve talked about how to build with CSS 3D Transforms as well as CSS Animations and Transitions in previous articles. In this article, I’d like to introduce a more “unconventional” use case for these technologies by describing the concept of “full-page animations” that can be used during the navigation process to add fluidity and continuity to browsing. Our target is to achieve a seamless browsing experience in which content smoothly appears into view when the user visits a page and transitions away when he clicks on a link or performs a relevant action.
These effects can be accomplished by transforming the HTML <body>
element using CSS Animations. However, this use case presents some considerations that we felt were worthy of discussion, such as the effect of layout and sizing on transforming <body>
, as well as how to appropriately time page navigations so that they mesh properly with our animations.
The code samples in this post use unprefixed CSS markup as supported by IE10 Release Preview; other browsers may require vendor prefixes for the CSS Animations and CSS Transforms properties used.
CSS Transforms are defined on the stylistic properties of an HTML DOM Element. For example, the markup for rotating an element 45 degrees along its Z axis would look like this:
Attaching a transform to the <body>
element of your HTML document works exactly the same way. So performing in order to declaratively add the same effect to your document’s <body>
you could do something like this:
Let’s look at a before-and-after shot of a page when applying a transform to the body
element:
Applying a rotateZ(45deg)
transform to the body
element of a document.
For three dimensional transformations, the CSS Transforms specification defines the perspective property that can be specified on the parent of the element that we transforming. When transforming the <body>
element of your content, it has to be applied to the <html>
element that resides above it in the DOM hierarchy. Doing so is straightforward:
Combining this with a rotateY(45deg)
transform on the <body>
element yields the following result:
Applying a rotate(45deg)
transform to <body>
with perspective: 500px
set on <html>
.
We can manipulate the transform-origin
property on the body
element for interesting results. Let’s look at a couple of examples:
The above markup sets a rotation along X for the body
element while shifting the origin of rotations to the bottom of the element using transform-origin
. Effectively this rotates the document’s contents “into” the screen like this:
We can also manipulate the perspective-origin
property on the root element of our document to achieve an off-axis projection effect. Changing the style for <html>
to:
Our page now looks like this:
By using CSS Transforms, we can easily manipulate the visual appearance of the entirety of our page’s content. Since the usual layout and sizing rules still apply, some transforms on the body
element (particularly ones that use percentage values or rely on the transform-origin
property) can result in different visual effects depending on the content of our page. Recall our previous rotateX(45deg)
example with transform-origin
set to 50% 100%
.
Below you can see the results before and after the transform is applied.
Notice how the content does not actually pivot on the bottom of the window but rather at some point outside of the viewport. This is expected behavior for CSS Transforms: the <body>
is laid out normally, then it is rotated along its bottom edge that is somewhere off screen. You will also notice that the actual foot print of the content has expanded (take a look at the scroll bars in the “after” picture) in order to accommodate the transformed content (the fact that we are using perspective projection makes this effect even more pronounced).
So how do we deal with arbitrarily sized content when applying transforms to our body
element? Custom tailoring all content in order to ensure that the size of the body does not expand more than a certain amount may be unrealistic. Instead, we can use a simple HTML/CSS pattern that allows us to fix the size of the body
element to that of the browser window and append content inside a wrapper <div>
. The following markup achieves just that:
The illustration below shows what happens when a page is scrolled vertically and we apply a rotateY(45deg)
transform to the <body>
element of our document directly (left) and using the wrapper pattern (right):
The direct application of the transform results in a skewed visual result due to the off-axis projection (since we are no longer looking at the “center” of the body
element). Using the wrapper pattern ensures that the <html>
element’s perspective-origin
property (50% 50%
by default) will always be correctly centered with relation to the <body>
element, giving us a pleasant visual effect.
By utilizing the above pattern and setting up CSS Transforms with percentage values whenever possible, we can affect our <body>
element in consistent ways, regardless of the size of its contents.
Having sorted out the intricacies of applying CSS Transforms to the <body>
element, CSS Animations are the next step. By following the principles described above, we can create animations that bring our Web content into view (or remove it from view) in interesting ways.
Consider this basic @keyframes
rule:
When applied to an element, this animation will cause it to rotate on its left side. When applied to a <body>
element that uses our wrapper pattern the visual result is more interesting. The document will actually rotate from outside of the visible area of the browser window and into full view:
Similarly, we can compose animations that fluidly remove our Web content from view. For example, if we wanted our page to disappear into the distance while rotating, we could use something like this:
@keyframes whirlOut { to { transform: scale(0) rotateZ(1260deg); } }
With the visual result being:
Since we can use the full power of CSS Animations to affect the entirety of our Web content, we have a lot of flexibility in terms of generating these page effects (and we are certainly not limited to just using CSS Transforms). But once we have composed the effects that we want to apply to our content, how do we cause them to trigger during the page navigation process?
<body>
Our goal is to use trigger animations at strategic times during the browser experience in order to give the appearance of content transitioning into view when a page loads and out of view when the user clicks on a link.
The first intuitive place to add an animation to the body
element would be the onload
JavaScript event. As it turns out however, adding an animation when onload
fires is actually too late. This event actually triggers when the entirety of the content in our page has finished loading (including any images or other bandwidth-intensive resources). Attaching an animation to onload
on a bandwidth-intensive page would result in our content displaying “normally,” followed by the animation triggering and re-bringing the content into view. Not exactly the effect that we were aiming for.
Alternatively, we could utilize the DOMContentLoaded
event that triggers when the browser has finished parsing the DOM structure of our content (but potentially before resources have finished loading). The IE Test Drive DOMContentLoaded demo illustrates the difference between these two events. However, in cases of complex Web content, a modern browser may choose to perform “progressive” rendering, displaying the page before the entirety of the DOM tree has been loaded. In these situations, the visual result would be similar to the onload
scenario.
The optimal place to set up an animation that transitions our page content in view is inline at the top of the <body>
element. This ensures that the animation will commence right as the content is being rendered (and that the starting position of the content will be that of the from
keyframe of our selected animation). A pleasant side effect of this approach is that the animation may actually mask any progressive rendering, re-layout or resource loading that can occur with complex content.
Setting up the animations that transition our content out of view is also interesting. One could assume that we could attach an onclick
handler to all elements of interest in our content (for instance all <a>
tags) and just set the relevant animation properties (animation-name
, animation-duration
, etc.) in the callback
function. However, if we do not actually delay the navigation from happening, we will not see our expected fluid transition.
This is a good opportunity to utilize the animation events described in the CSS Animations specification. In particular, we can use the animationend
event to detect when the animation has completed and then trigger a navigation (by setting window.location.href
, for instance). Thus our onclick
will trigger the “remove-from-view” animation and register a handler for animationend
on <body>
that will ensure that the navigation event occurs.
We’ve created a demonstration and tutorial on bringing pages alive with CSS Transforms & Animations that provide depth and examples beyond what we’ve been able to show here. The tutorial itself utilizes full page animations during page navigation that work in Internet Explorer 10 on Windows 8 as well as recent versions of Chrome and Firefox.
To simply enjoy the page-to-page animations, step through the pages of the tutorial using the “Continue to …” links in the lower right corner of each page.
At the end of the tutorial we provide some additional guidance and sample code on how to incorporate these animations with your own Web content.
CSS Transforms and CSS Animations are two powerful feature-sets that enable richer and more immersive Web experiences. With a small amount of effort you can create Web pages (even static ones) that provide a fluid and almost app-like navigation experience.
Courtesy : Sitepoint