Wednesday, June 10, 2015

10 Types Of Visual Content That Will Improve Your Social Engagement - #Infographic

Never face creative block again. Bookmark this resource, now! titled: 10 Types Of Visual Content You Should Include in Your Marketing Strategy - #infographic

97% of the impact on an audience comes from the visual message that you are conveying, not the actual text of the content itself. It has been proven that people respond differently to what they see rather than what they think they need to engage with. This is an important consideration to achieve your marketing goals with the marketing tactics and strategy that you will be executing. If your end goal is to get sales, a humourous advertisement may get people talking about your product. However, it may not transfer into sales. Likewise, a visually appealing picture may be shared virally online, but without a captivating call to action, the results of the campaign may suffer.

There are digital agencies who understands the content structures and strategies that are required to execute a successful marketing campaign. As a marketer, you need to give people the content that appeals to them. Rather than recreating the wheel, businesses can adopt methods used in their successful campaigns and implement it into your campaign.

Online, the majority of people engage with visual images. People also respond to direct messages in text. You can see this with the popularity of shared content in the forms of picture images, memes, videos and infographics. Below are some of the points to bear in mind when using visuals as a part of your content marketing.

by Irfan Ahmad via Digital Information World

Malte Demuth

Malte Demuth works as an independent Creative Director Online in Berlin. He brings in a decade of work experience to solve high-level First World Problems.


by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery

Building Product Documentation with MkDocs

There's a popular maxim that "a product is as good as its documentation". This holds true as much for software as it does for physical products.

As a small, indie developer who doesn't specialize in front-end design, I often hire a freelancer to build my product website—which, of course, usually includes a documentation section.

A documentation section can take quite a bit of time and money to build, even for a simple product, so it would be nice not to have to reinvent the wheel for every site. Fortunately, there is a way.

Introducing MkDocs

MkDocs is a free, static site generator geared towards building project documentation. It can be used to generate a stand-alone site, or just a documentation section of a larger site.

Because MkDocs produces static files, your documentation is light-weight and easy to host—using free services such as GitHub Pages and Read The Docs—or of course on your own server.

In this article, I'll introduce MkDocs, showing you how to install it, build documentation with it and finally host the generated documentation on a web server.

To get a sense of the sort of documentation MkDocs produces, have a look at my ProfilePress WordPress plugin documentation, which is built with MkDocs using the Read the Docs theme.

MkDocs is written in Python. The documentation source files are written in Markdown, and configured with a single YAML configuration file.

To build documentation with MkDocs, you need to have it installed locally in your computer. So let's next look at how to install it.

Installing Python and MkDocs

Static site generators like Jekyll (used mainly for blogging, and built on Ruby) and MkDocs do require some command-line chops, so be warned. However, to those not used to working with the command line, I encourage you to read on and give it a try, as it's not as bad as it looks!

Installing Python and pip

To install MkDocs, you need to have Python and pip (a Python package manager) installed in your computer. They may already be installed on your computer. If you have Python 3.4 or later installed, you probably have pip installed. (See the Python installation guide for full instructions.)

To install Python on a Linux distribution such as Ubuntu, see this stackoverflow thread or do a Google search for your distribution.

For Windows, download your preferred version installer and run the file to install Python.

Alternatively, if you have the Chocolatey package manager installed in your machine, run choco install python.

To verify that your Python distribution has pip installed, run the pip --version command. Otherwise, run python get-pip.py or choco install pip via Chocolatey to get it installed.

Installing MkDocs

Now that Python and pip are installed, run pip install mkdocs to install MkDocs.

To confirm everything is fine, run mkdocs help to give mkdocs command a try.

If you are on Windows and the mkdocs command isn't alive, be sure to add C:\path-to-python-folder\Scripts to Path environmental variable.

Building the Documentation

Now that you have Python and MkDocs set up, you can get on with your actual documentation.

Firstly, create a project for the documentation (let's call it sp-doc) and navigate to the created folder:

$ mkdocs new sp-doc
$ cd sp-doc

The generated project folder will contain a docs folder—where the Markdown files for the documentation will be stored—and the configuration file mkdocs.yml.

Here is the directory structure:

|-- docs              # MD doc pages
    |-- index.md
|-- mkdocs.yml        # config file

Add the following bare-minimum configuration to mkdocs.yml file:

site_name: SitePoint Documentation
site_description: Description of the documentation
theme: readthedocs
pages:
- ['index.md', 'Index']

MkDocs ships with a number of themes—such as "MkDocs", "Read the Docs" and "Bootstrap". Say you intend to use the default theme. In that case, simply replace readthedocs with mkdocs in the code above.

The pages config is used to determine the set of pages that should be built for the documentation and the navigation menu.

Markdown files added to pages must be relative to the docs folder. For example, if you created a new folder called config inside the docs directory and added a setup.md file in it, here's how you would add it to pages in the mkdocs.yml file configuration:

site_name: SitePoint Documentation
site_description: Description of the description
theme: readthedocs
pages:
- ['index.md', 'Index']
- ['start.md', 'Get Started']
- ['config/setup.md', 'Configuration', 'Setup']
- ['config/debug.md', 'Configuration', 'Debug']

This creates some new pages that appear automatically in our documentation menu. Firstly, there's a start.md page, with the title "Get Started".

We've also added a new section to the documentation menu called "Configuration", under which there's a link to new Setup and Debug pages.

MkDocs includes a built-in web server, so you can preview your documentation locally as you work on it.

To start the web server, ensure you are in the directory where mkdocs.yml config file resides, and then run the mkdocs serve command.

Visit http://127.0.0.1:8000 in your browser to view the documentation:

Preview of generated MkDocs documentation

If you're satisfied with what you've created, run mkdocs build to generate the static files for the documentation which will be saved to site directory.

You can copy the static files and host them on a web server of your choosing to take the documentation live.

In the next section, we'll learn how to deploy MkDocs to Read the Docs and GitHub Pages.

Continue reading %Building Product Documentation with MkDocs%


by Agbonghama Collins via SitePoint

The Dawn of WebRTC

Web Real-Time Communications (WebRTC) was built to provide developers with the ability to create high definition video and audio calls using simple JavaScript APIs. These APIs are embedded directly in the browser and require no plugins, downloads, or installation of any type to get you up and running. Google spent about $200 million to open source the technology giving it to the development community. WebRTC uses several codecs for video and audio giving anyone the ability to create next generation communication apps without the need to pay for licensing or royalties.

What are the Possibilities?

We have only begun to scratch the surface of how WebRTC will change the communications industry. We are seeing all types of applications being created with WebRTC. One of the most iconic examples is Amazon's Mayday Button. It shows the true power of how WebRTC is being harnessed by companies large and small. WebRTC brings many abilities for you to enhance your apps such as:
  • Video Communications: Create secure and high definition audio and video streams between browsers
  • File Sharing & Messaging: Securely connect and share data between browsers without the need to upload files to the cloud or a network server. Data is sent directly between the connected peers
  • Phone to Browser: WebRTC allows for connections between Public Switched Telephone Network (PSTN) and browsers. You can make and receive calls all from one location with the use of the new APIs in HTML5, a SIP Gateway and WebRTC
  • Mobile to Mobile: WebRTC is not just for the web, there are native libraries for both iOS and Android that utilize WebRTC's capabilities
  • Machine to Machine: WebRTC is embeddable for systems needing to communicate machine to machine such as with the Internet of Things. Google Chromecast is a perfect example of using WebRTC outside the normal use case

Understanding the WebRTC APIs

WebRTC relies on three JavaScript APIs embedded directly into web browsers requiring no client or browser plugin in order to communicate directly with another WebRTC enabled browser. These APIs are:
  • MediaStream (aka getUserMedia) allows you to gain access to the camera, microphone, or screen of the device employed by the user. As an added layer of security, the user will have grant access before you will be allowed to stream their media. If the user connects from a secure connection (HTTPS) the user will only need to grant access once for the application but if you connect from a non-secure connection (HTTP) the user will be prompted each time the application needs access
  • RTCPeerConnection (aka PeerConnection) allows two users to communicate directly, peer to peer. It encodes and decodes media sent to and from your local machine to a remote peer receiving your media.
  • RTCDataChannel (aka DataChannel) represents a bi-directional data channel between two peers. It piggy backs on top of the RTCPeerConnection allowing you to send data directly between the two connected peers securely.

Continue reading %The Dawn of WebRTC%


by Lantre Barr via SitePoint

The Future Generation of CSS Selectors: Level 4

Back in January 2014 I wrote the article The Current Generation of CSS3 Selectors. The goal of that article was to introduce the new generation of selectors that often fell under the “CSS3” umbrella. That group of selectors has been well documented in a lot of places, and browser support for those features is quite strong (all browsers including IE9+).

The future of CSS selectors is also looking bright, with the Selectors Level 4 specification currently in Working Draft status, and an Editor’s Draft of the same spec still in progress (the editor’s draft is generally viewed as more authoritative).

This article will focus on the new selectors not discussed in my previous article. Browser support for many of these is pretty poor, so I don’t recommend using many of these in production. View this post as a peek into what’s to come when the spec is further along and browsers start their implementations. I’ve included demos for those that have support.

:read-only and :read-write

These selectors are pretty straightforward. Any element that’s editable by the user is in the “read-write” state. Otherwise, the element is in the “read-only” state.

Take the following HTML:

[code language="html"]
[/code]

Now consider this CSS:

[code language="css"] :read-only { outline: solid 1px blue; } :read-write { outline: solid 1px red; } [/code]

Here’s a breakdown of what this CSS does in relation to the HTML:

  • The first two elements will have a blue outline because they are set to “readonly” and “disabled” in the HTML, respectively.
  • The third element will have a red outline because it’s naturally editable (“read-write”), as are all inputs by default. A textarea would be the same.
  • The last element (the div) will have a red outline because of the contenteditable attribute.

In the CSS I’m using these selectors universally (i.e. without applying them to any elements). This means the red outline would be applied to all divs, spans, and other naturally uneditable elements. It’s more likely that this would be used on specific form elements or elements with a class applied, to be more specific.

The :read-write pseudo-class is listed as “at-risk” in the Editor’s Draft, so it may be removed.

Browser Support for :read-only and :read-write
Chrome, Opera, Firefox, Safari.

Note: As shown in the demo below, the browsers that support these selectors identify the "disabled" input as "read-write", which is not correct, according to the spec.

See the Pen Demo for :read-only and :read-write by SitePoint (@SitePoint) on CodePen.

The Default-option Pseudo-class: :default

The :default pseudo-class matches elements that qualify as “default” in relation to a set that they are part of. For example, a button element that’s the default submit button for a form or the default selected item in a set of radio buttons.

You can also have multiple defaults for a single group, as shown in this HTML snippet:

[code language="html"]
Fruits Vegetables Meats Poultry Nuts Breads [/code]

Now let’s pair the HTML above with the following CSS:

[code language="css"] input[type=checkbox]:default { outline: solid 1px hotpink; } [/code]

In this case, all the elements with the checked attribute present will be styled with the outline.

Browser Support for :default
Chrome, Opera, Firefox, Safari.

As shown in the demo, WebKit/Blink browsers do not apply the outline to the “default” checkboxes, even though they should. This seems to be a bug. Firefox has the correct behavior.

See the Pen Demo for :default by SitePoint (@SitePoint) on CodePen.

Validity Pseudo-classes: :valid and :invalid

These pseudo-classes are useful in HTML forms for giving visual clues as to the validity of the data entered by the user, something that would normally be done with JavaScript.

As an example, if your form has the following field:

Continue reading %The Future Generation of CSS Selectors: Level 4%


by Louis Lazaris via SitePoint

Multiple Editors per Node in Drupal 7

One of the things that makes Drupal great is its flexible user permission system. The out of the box permissions grid we are all familiar with covers most uses cases of controlling what users can and cannot do. It is also very easy for module developers to create new permissions and roles that restrict the logic they implement.

Drupal logo

Nevertheless, I have encountered a practical use case where the default configuration options are not enough. Namely, if you need to have multiple users with access to edit a particular node of a given type but without them necessarily having access to edit others of the same type. In other words, the next great article should be editable by Laura and Glenn but not by their colleagues. However, out of the box, users of a particular role can be masters either of their own content or of all content of a certain type. So this is not immediately possible.

In this article I am going to show you my solution to this problem in the form of a simple custom module called editor_list. Article nodes will have a field where you can select users and only these users (or those who have full access) will be able to edit that particular node. You can find the module already in this git repository and you can install it on your site for a quick start. Do keep in mind that it has a dependency on the Entity Reference module as we will see in a minute.

I will keep the code comments to a minimum to save space but you can find them in the repository if you want. Basic knowledge of Drupal 7 is assumed in the remainder of this tutorial.

Continue reading %Multiple Editors per Node in Drupal 7%


by Daniel Sipos via SitePoint

YAY

opl-small

Colorful parallax scrolling One Pager for 'YAY' - a French graphic design studio. I pretty much love everything about this portfolio. The color, the subtle parallax, the hover effects, the minimal amount of project detail (copy + images) and just love how the logo changes as you scroll (consistent with the preloader).

by Rob Hope via One Page Love