    
|
While the good old resume is in no danger of disappearing, you’d better have your online profiles in shape.
Something like 80% of all employers check you out online when you apply for a job. Assuming that you’re smart enough to have tailored your Facebook profile during the job hunt, you need tofocus on the things that will get you noticed, examined and hired.
While it used to be true that LinkedIn was THE place to host your professional profile, upstarts like BeKnown (from Monster) are making headway in the social job hunt. You’ll want to test out the new sites by building a profile and watching the results. It’s worth noting that the newer entrants have more reason to work for your success. After all, like you, they are trying to make a name for themselves.
When you post a profile or resume somewhere, you only have one goal: to get noticed by the right recruiter for the right job. Once your resume is on the list, it needs to grab the recruiter’s attention with data points that highlight your success and effectiveness in jobs like the one you want. Your profile needs to scream “Pick me! pick me! pick me! Hey, look over here and pick me.”
Here are five steps to improve your profile to get the attention you want.
The profile is here to stay. You have to manage it like it was a new puppy. By paying attention to the grooming and feeding of your online profiles, you can increase the chances of finding the job you want.
]]>|
|
The DOE Scholars Program offers unique opportunities that introduce students or post-graduates to the agency’s mission and operations. Participants in the DOE Scholars Program gain a competitive edge as they apply their education, talent and skills in a variety of scientific research settings within the DOE complex. Appointments are available in a variety of disciplines at participating DOE facilities nationwide.
Being selected as a DOE Scholar offers the following benefits:
- Career possibilities with the nation’s leading sponsor for scientific research
- Opportunities to learn from top scientists and subject matter experts
- Stipends of up to $650 per week (depending on academic status)
- Travel arrangements to and from appointment site
Applicants must be US Citizens and undergraduates, graduates or post-graduates of an accredited college or university. The program is open to majors in: Engineering; Physical Sciences; Environmental Sciences; Computer Science and Information Technology; Physics; Business; Policy; Program Management; Mathematics; Statistics; Safety and Health; Accounting and Finance; Law; Communications; and other related areas.
]]>
Want to learn more about the DOE Scholars program? E-mail doescholars@orise.orau.gov or visit website.
Love it or hate it, it’s getting difficult to deny generative typography’s steadily increasing importance in the world of graphic design, and according to a new short film, On Generative Typography, that influence will only continue to grow.
New York brand and experience design firm Collins produced the film to promote the Type Directors Club’s open call for entries to their annual competitions.
On Generative Typography runs just under seven minutes, and features four prominent designers and typographers from around the world discussing their thoughts on generative design as a trend, from how it developed, how it can or should be used, to predictions for its impact on the future of typography and design overall.
Rather than…a set of punches and chisels, we now have, you know, a set of APIs that we can use to program a typeface. — Project Projects founder, Prem Krishnamurthy.
For those unfamiliar with the subject, generative typography is a new method of interpreting text using a variety of factors, chosen by its designer, and a unique, code-driven algorithm to influence the rendering of a typeface (or typefaces). The output then, is a new kind of text, one which constantly changes and evolves with the data it represents. (A fantastic interactive example of generative typography at work can be seen on the Type Directors Club’s microsite, type generator.)
Also weighing in on the matter are Project Projects principal Rob Giampetro, Dutch typographer and professor of typography Petr Van Blokland, and Pentagram partner Natasha Jen. Their opinions and predictions provide some unique and polarizing food for thought; is generative typography the future of not only design, but also language and typography at large?
What do you think of generative typography? How will it impact web design? Let us know your thoughts in the comments.
| Picons: 650+ Professional, Simplistic Icons – only $24! |  |
|
|
 |
Some websites outperform others, whether in their content, usability, design, features, etc. Details of interaction design and animation make a fundamental difference on modern websites. We’ll share some lessons drawn from various models and analyze why these simple patterns work so well.
When we design digital products, we often use design applications such as Photoshop and Sketch. Most people who have been in the business for a few years obviously know that design is more than just about visual presentation. Still, many continue to create static designs. Steve Jobs said this about design:
“It’s not just what it looks like and feels like. Design is how it works.“
Our experience and impression of a product are shaped by a combination of factors, with interaction playing a fundamental role. No longer can we think of user interfaces as static designs and add the magic of interaction later on. Instead, we need to embrace the interactive nature of the Web from the very beginning and think of it as natural constituent.
Let’s look at some examples in which smart interaction, defined by subtle animation, gently improves the user experience.
The blessing and the curse of the Web are hyperlinks. When you click on a link, it could take you anywhere, from a product page to the website of the creepy old puppet store down the street. The result is a loss of context.
One of the great things about the user experience of books is the linearity. Every chapter in a book builds on the last. You must read chapter one in a primer on economics to understand chapter two. When you skip a chapter, you are aware that you might miss something and, thus, lack some knowledge about the subsequent content. On the Web, and especially on long websites, this often happens subconsciously. By adding a scrolling animation, we can fix that:
Compare that to this:
Compare the default behavior of “name” anchor links with the animated behavior. Skipping content is not an unconscious action anymore; it’s a decision. In fact, Hope Lies at 24 Frames Per Second has a menu button for its mobile view that sends you to the top of the page, without any animation. It took me more than a minute to figure out what actually happened.
Takeaway: Abrupt changes in an interface are hard for users to process. Don’t leave them in the dark; always show what’s happening.
As we saw in the last example, transitions help users understand the pace and flow of an interface. Nothing feels more unnatural than a sudden change, because sudden changes just don’t exist in the real world. Let’s look at another example: toggle menus. Users associate the “plus” symbol with the action of adding content or expanding an element. By rotating it by 45°, the plus becomes a cross, an interface element widely understood to mean “close”:
This simple transition completely changes the meaning of the icon. Such a small detail means the difference between having to guess what will happen next and knowing what the icon means in either state. That toggle is pretty user-friendly, if you ask me. Also, note that the plus sign always rotates in the same direction as the content, reinforcing the flow of information.
Takeaway: Make your website element understandable in each state.
The comment forms on many blogs and news websites are not the happiest-looking elements. Why? Well, most of them are not exactly friendly, right? When you are ready to post a comment, you just want to start typing the comment itself and nothing else. Instead, a typical form asks you all kinds of other stuff first. It’s annoying.
To motivate people to comment more, we can collapse the form and show only the most crucial element: the comment field. When the user clicks on the field, you can expand the form accordingly. A real-world example of this progressive disclosure can be found on the New York Times’ beta website:
You could take this even further by setting the cursor’s focus to the comment field when the form expands. This approach has a problem, though: A key principle of interaction design is that an action should always happen close to where the interaction occurs (near the locus of attention). We could go one step further, then, and animate the comment field to orient the user:
You could even pin the comment field to the top, expand it accordingly and display additional fields below it.
As you can see, this reduces clutter and makes the comment form more inviting. But what about collapsing all of the previous comments, too?
By collapsing the comments, we get the scroll bar to represent the length of the article itself, instead of the entire page. A common practice is to automatically load comments when the user reaches the bottom of a page. We should avoid forcing the user to click unless there is a really good reason to.
Takeaway: Progressively disclose in order to reduce UI components to their essence. Reveal features as the user needs them.
One of the most exciting interactions to emerge shortly after the introduction of the iPhone was “pull to refresh,” pioneered by Loren Brichter. It allows the user to update scrollable reverse-chronological content. You can see this concept in action in Twitter’s app. Once you’ve scrolled to the top of the stream of tweets, scroll a little further to refresh the stream.
Why does this work so well? Before pull to refresh existed, users had to hit the refresh button in their browser to load more content. By connecting the user’s desire of finding more content with the action of refreshing, the need for an explicit action became obsolete.
Takeaway: By connecting intent with action, the experience becomes more seamless.
Sticky labels are another subtle yet useful combination of a user-interface component and a meaningful transition. Check out Edenspiekermann’s use of this technique in its portfolio.
The project label scrolls along with the content, thus providing context for the images on the right, until the next project appears. This behavior is similar to that of the address book in iOS and is especially helpful for providing context in long sections. The transition offers both improved orientation and smooth context-based descriptions.
Takeaway: Use sticky labels for long sections in which descriptions or titles add valuable information to content that doesn’t fit in the viewport.
The concept of affordance derives from cognitive psychology and refers to particular characteristics of an object that guide the viewer.
In the context of user-interface design, the usability glossary (PDF) of the EU’s website defines it as follows:
“An affordance is a desirable property of a user interface — software which naturally leads people to take the correct steps to accomplish their goals.”
Ridges are often used to enhance affordance. Ridges around a button suggest that the button can be manipulated. This UX technique was widely popularized by the camera app in iOS.
iOS 6’s lock screen featured ripples around the camera icon, suggesting draggability. Apple removed it in iOS 7, apparently because users got accustomed to it, making the icon look more like a standalone button now. What happens is still the same, though: When you drag the button, the lock screen bounces up, revealing the camera underneath. This is a great technique to point users to features in an interface.
Takeaway: Give elements a high affordance to point users to features in an interface.
Google Chrome on iOS has had context-based hiding since it launched. This is what it looks like:
The basic idea is that the browser chrome and navigation controls hide automatically once the user scrolls down. As soon as the user scrolls up again, the controls reappear. This approach both enhances the contextual experience (focusing on the content itself) and increases screen space. The latter is, of course, particularly important on mobile devices.
The underlying assumption is that users will flow with the content that they’re consuming. As soon as they stop the flow, a change of context is likely required; thus, the navigation controls reappear. While this technique saves screen space, check whether the assumption holds up in your use case.
iOS takes this a step further. When you reach the bottom of a page, the controls expand again. It’s a good example of dynamically incorporating the needs of the user in an interface.
Takeaway: Use context-based hiding to enhance the user’s focus and save screen space.
About a week ago, Nikita Vasilyev, a Toronto-based UI designer, came up with a pretty neat idea. He developed a script that animates focused elements. While still experimental, the concept is pretty interesting. Have a look at his video below. (And please put your earphones on — the music is epic.)
When navigating by keyboard, the user is often not clear on where the focus has moved to upon pressing the Tab key. Animation points them to the right spot on the page. The transition is subtle but has a big impact on orienting the user.
Takeaway: Orient the user, regardless of how they navigate.
These are only a few examples, among many others out there. The point is not to show the latest and fanciest interaction techniques, but rather to highlight how small interaction details can significantly improve the user experience.
If we are to design better digital products, then we need to challenge our current beliefs and see how interaction patterns can potentially ease the user’s life. I’m not saying we should reinvent the wheel, but it would be pretty naive to stop exploring. So, get out of your comfort zone. Keep exploring and testing.
If you like this article, you can follow me on Twitter, or join me for a bar of Swiss chocolate in Switzerland.
Which transition patterns have you found especially useful in your projects?
(al, ea)
© Adrian Zumbrunnen for Smashing Magazine, 2013.
]]>
When Google and other search engines index websites, they don’t execute JavaScript. This seems to put single page sites — many of which rely on JavaScript — at a tremendous disadvantage compared to a traditional website.
Not being on Google, could easily mean the death of a business, and this daunting pitfall could tempt the uninformed to abandon single page sites altogether.
However, single page sites actually have an advantage over traditional websites in search engine optimization (SEO) because Google and others have recognized the challenge. They have created a mechanism for single page sites to not only have their dynamic pages indexed, but also optimize their pages specifically for crawlers.
In this article we’ll focus on Google, but other large search engines such as Yahoo! and Bing support the same mechanism.
When Google indexes a traditional website, its web crawler (called a Googlebot) first scans and indexes the content of the top-level URI (for example, www.myhome.com). Once this is complete, it then it follows all of the links on that page and indexes those pages as well. It then follows the links on the subsequent pages, and so on. Eventually it indexes all the content on the site and associated domains.
When the Googlebot tries to index a single page site, all it sees in the HTML is a single empty container (usually an empty div or body tag), so there’s nothing to index and no links to crawl, and it indexes the site accordingly (in the round circular “folder” on the floor next to its desk).
If that were the end of the story, it would be the end of single page sites for many web applications and sites. Fortunately, Google and other search engines have recognized the importance of single page sites and provided tools to allow developers to provide search information to the crawler that can be better than traditional websites.
The first key to making our single page site crawlable is to realize that our server can tell if a request is being made by a crawler or by a person using a web browser and respond accordingly. When our visitor is a person using a web browser, respond as normal, but for a crawler, return a page optimized to show the crawler exactly what we want to, in a format the crawler can easily read.
For the home page of our site, what does a crawler-optimized page look like? It’s probably our logo or other primary image we’d like appearing in search results, some SEO optimized text explaining what the site is or does, and a list of HTML links to only those pages we want Google to index. What the page doesn’t have is any CSS styling or complex HTML structure applied to it. Nor does it have any JavaScript, or links to areas of the site we don’t want Google to index (like legal disclaimer pages or other pages we don’t want people to enter through a Google search). The image below shows how a page might be presented to a browser (on the left) and to the crawler (on the right).
Typically, single page sites link to different content using a hash bang (#!). These links aren’t followed the same way by people and crawlers.
For instance, if in our single page site a link to the user page looks like /index.htm#!page=user:id,123, the crawler would see the #! and know to look for a web page with the URI /index.htm?_escaped_fragment_=page=user:id,123. Knowing that the crawler will follow the pattern and look for this URI, we can program the server to respond to that request with an HTML snapshot of the page that would normally be rendered by JavaScript in the browser.
That snapshot will be indexed by Google, but anyone clicking on our listing in Google search results will be taken to /index.htm#!page=user:id,123. The single page site JavaScript will take over from there and render the page as expected.
This provides single page site developers with the opportunity to tailor their site specifically for Google and specifically for users. Instead of having to write text that’s both legible and attractive to a person and understandable by a crawler, pages can be optimized for each without worrying about the other. The crawler’s path through our site can be controlled, allowing us to direct people from Google search results to a specific set of entrance pages. This will require more work on the part of the engineer to develop, but it can have big pay-offs in terms of search result position and customer retention.
At the time of this writing, the Googlebot announces itself as a crawler to the server by making requests with a user-agent string of Googlebot/2.1 (+http://www.googlebot.com/bot.html). A Node.js application can check for this user agent string in the middleware and send back the crawler-optimized home page if the user agent string matches. Otherwise, we can handle the request normally.
This arrangment seems like it would be complicated to test, since we don’t own a Googlebot. However Google offers a service to do this for publicly available production websites as part of its Webmaster Tools, but an easier way to test is to spoof our user-agent string. This used to require some command-line hackery, but Chrome Developer Tools makes this as easy as clicking a button and checking a box:
Open the Chrome Developer Tools by clicking the button with three horizontal lines to the right of the Google Toolbar, and then selecting Tools from the menu and clicking on Developer Tools.
In the lower-right corner of the screen is a gears icon: click on that and see some advanced developer options such as disabling cache and turning on logging of XmlHttpRequests.
In the second tab, labelled Overrides, click the check box next to the User Agent label and select any number of user agents from the drop-down from Chrome, to Firefox, to IE, iPads, and more. The Googlebot agent isn’t a default option. In order to use it, select Other and copy and paste the user-agent string into the provided input.
Now that tab is spoofing itself as a Googlebot, and when we open any URI on our site, we should see the crawler page.
Obviously, different applications will have different needs with regard to what to do with web crawlers, but always having one page returned to the Googlebot is probably not enough. We’ll also need to decide what pages we want to expose and provide ways for our application to map the _escaped_fragment_=key=value URI to the content we want to show them.
You may want to get fancy and tie the server response in to the front-end framework, but I usually take the simpler approach here and create custom pages for the crawler and put them in a separate router file for crawlers.
There are also a lot more legitimate crawlers out there, so once we’ve adjusted our server for the Google crawler we can expand to include them as well.
Do you build single page sites? How do single page sites perform on search engines? Let us know your thoughts in the comments.
Featured image/thumbnail, search image via Shutterstock.
| Verb: 72-Font Super Family (the complete series) – only $37! | |
|
|