7 Tips for Improving Your Social Media Marketing Strategy

If you are like most business owners, CMOs, or content strategists, you sit down once a year or more frequently to design your social media strategy. The important question is, what are you doing during those planning sessions. Are you simply renewing the previous strategy and possibly adding some new social media marketing technology? Are you simply doubling your efforts in hopes that more is better? A solid content marketing strategy is gold. It provides the framework for your social media efforts, leaves room for improving those efforts, and provides a way to determine if the strategies applied are actually working. If your content marketing strategy is stale, ineffective, or incomplete, your social media campaigns will follow down the same path. To avoid this, check out these 7 tips for making your social media strategy better.

by Guest Author via Digital Information World

The UX Mastery Community Forums are Moving House

We have some exciting news! The UX Mastery community forums are moving to a shiny new home. We launched our discussion forums a couple of years ago, and while we’re exceptionally proud of the results, the irony of having a platform that offers a marginal user experience (and that’s being generous) isn’t lost on us. We’ve decided to do something about it—we’re migrating away from vBulletin onto the excellent Discourse.

I’ve undertaken a couple of Discourse migration projects in the past, and can declare both a success, so we don’t envisage any snags this time around.

Aesthetics aside, Discourse offers good solutions to a number of issues that we’re currently experiencing with vBulletin:

• It’s open source, which gives us the ability to customise the experience to suit you – our community.
• It is easily integrated with WordPress, affording us the ability to create a seamless UX Mastery experience in the future.
• The flexible user preferences mean that you can tailor the nature and cadence of your own notifications to suit the way you choose to use the platform.

We’re currently running a test migration which will take a couple of weeks to iron out. All going to plan we should have something ready to show you in the next month. Exciting!

We’re doing our best to minimise the inconvenience for you, and we’ll continue to keep you in the loop here on the blog, in our newsletter and on our existing forums as we move further through the process.

If you have any questions, just ask. We’d love to discuss this with you.

The post The UX Mastery Community Forums are Moving House appeared first on UX Mastery.

by Sarah Hawk via UX Mastery

Simple Ajax Uploader

A Javascript plugin for cross-browser Ajax file uploading. Supports drag and drop, CORS, and multiple file uploading with progress bars. Works in IE7-9, mobile, and all modern browsers.

by via jQuery-Plugins.net RSS Feed

Look Ma, No Server: Developing Apps with Angular 2 MockBackend

Getting your front-end and back-end teams up to full speed is certainly something each company is looking for. Often though, what happens is that the teams fall into the pit of blocking dependencies. Those are situations where the upcoming work of one team is blocked by a user story owned by the other team.

One of those examples is the communication process between the front- and back-end. These days REST APIs have ascended the throne of so-called communication standards. The benefit of using JSON, a simple yet effective data transfer format, is that front-end workers do not need to care about the actual back-end anymore. Whatever crosses the wire is directly consumable and may be leveraged to bring data into your application. So it's not surprising that those elementary entities often do not get modeled at all on the front-end and are consumed as they arrive. This brings us to the fundamental problem of having to wait for the back-end team to provide something useful. As depicted in the following figure, we see that both teams start in parallel, but at a certain time one team is kept waiting for the other to catch up.

Besides this, having no kind of fixed structure makes each change a potentially dangerous one. So the focus of this article is to present a way that front-end teams can become independent of the back-end and at the same time provide a useful interface which reduces the risk of structural changes.

A Ticketing System Without a Real Back-end

In order to achieve that independence it's imperative to start thinking upfront about your project. What entities are you going to use? What communication endpoints result therefore?

This can be done by creating a small table highlighting the necessary REST endpoints and describing their purpose. Remember the reason we are doing that upfront is for both parties to agree upon a common structure for communication. That does not mean it has to be perfectly done but it should help you get started with the most important steps. As time passes, just update your interface accordingly with the new routes needed.

The actual process of creating a back-endless environment is to capture all HTTP requests and instead of letting them go out into the wild, reply with a fake response containing the information we'd like to have. This article will demonstrate the approach by describing a simple ticketing system. It uses the endpoints shown in the following table.

Please note that the example utilizes the POST verb for both the update and create route. Another option would be to leverage PUT for the update process. Keep in mind though that PUT should be idempotent, meaning every consecutive call has to produce the same result. Feel free to choose whatever suites your needs.

Method	Route	Request body	Description
GET	/ticket	None	Request all tickets
GET	/ticket/:id	None	Request a single ticket via the provided :id parameter
POST	/ticket	Ticket entity	Create a new or update an existing ticket
DELETE	/ticket/:id	None	Delete a ticket, identified by the :id parameter

Table 1: Consumed endpoints of the ticketing system

The Ticket entity is a simple TypeScript class containing some basic ticket information:

    export class Ticket {
      public _id: string;
      public title: string;
      public assignedTo: string;
      public description: string;
      public percentageComplete: number;

      constructor(id: string, title: string, assignedTo: string,
            description: string, percentageComplete: number) {
        this._id = id;
        this.title = title;
        this.assignedTo = assignedTo;
        this.description = description;
        this.percentageComplete = percentageComplete;
      }
    }

ticket.entity.ts describing the ticket entity

You may find the complete code as well as a preview for this example on Plunker:

The Angular 2 project setup

Enough theory, lets get our hands dirty with some coding. The project structure shown here is built upon the proposed Angular 2 Getting Started guide. As such, we won't waste too much time explaining every part of it. If you're searching for a introductory article, take a look at Getting Started with Angular 2 using TypeScript. For this article, you can just open up the above mentioned Plunker to follow the code parts explained below.

As most single page applications start with an index.html file, lets take a look at it first. The first section imports the necessary 3rd party dependencies and Angular's application files located in the vendor sub-folder. The Reactive Extensions (Rx) aren't actually a true dependency but will simplify the work with Angular's observables, which are the replacement for the previously used Promises. I highly recommend this article by Cory Rylan to learn more about the topic.

Note that manual script referencing is not the recommended way to create production-ready apps, nor is the framework itself either, being in beta state. You should use a package manager like npm or jspm. The later one works hand in hand with SystemJS, described in section two. SystemJS is a module loader previously based on the ECMAScript 2015 draft and now part of WHATWG's Loader specification. As such, it enables the use of the import x from 'module' syntax. In order to use it properly we need to configure it and then import the application's main entry point, the file app/boot.ts.

Note that we configured the defaultExtension so that we can omit the file extension in our import statements.

Finally we create the app by using a custom tag named my-app. Those are called Components and are somewhat comparable to Angular.JS 1.x directives.

Continue reading %Look Ma, No Server: Developing Apps with Angular 2 MockBackend%

by Vildan Softic via SitePoint

Free Coffee Break Course: Using Linux for Ruby Development

XOXO 2016

Dazzling teaser page for the upcoming XOXO festival happening in Portland in September.

by Rob Hope via One Page Love

How You Can Use Responsive Web Components Today

A few years ago I started to hear a lot about Web Components. I got pretty excited and then totally forgot about them as the noise settled down. It turns out there has been some good movement and support is starting to increase. Responsive Web Components, in particular, are set to really simplify how we approach responsive design. As promising as this sounds, there are four questions many developers out there will want to know before they start using them today:

Will they...

• Fit into the current state of the web?
• Work cross browser?
• Adapt to fit the space they are dropped into?
• Promote modular code?

In this article, we will explore the answers to each of those questions!

What Are Web Components?

Essentially, they are a W3 specification that enables you to build your own HTML elements. If you literally don’t know anything about them it may be worth having a quick read up about them as some of the terms I use in the article require a basic understanding.

Why Would I Want To Use Them?

A good example of when you might want to use Web Components would be when you are building UI that doesn’t exist natively in the browser — elements such as color pickers, carousels, accordions or typeaheads. Alternatively, you are likely to have some components that you use all the time across various sites that you are sick of rebuilding every time. These are things like social buttons, subscribe forms or notifications. With Web Components you can bundle up your markup, styles and scripts into encapsulated modules using HTML tags like <color-picker></color-picker> to reference them. This will seem familiar if you have used Angular directives or React components but the benefit here is that it is native to the browser and framework agnostic.

Web Components enable you to build pieces of UI once and use them everywhere. This is ideal for projects like a living styleguide where you want to build a library with a single source of truth for each of your components. This approach means repeating less code and having portable components that you or your team can simply drop references to into your interface.

Another big advantage of using Web Components is the ability to package these components up and share them with other developers or website owners. Essentially, the consumer can put an import statement in their web page such as:

[code language="html"]
<link rel="import"
href="http://ift.tt/256K6FD;
[/code]

Then use the custom element tag you've defined in that component. With this imported into their webpage, they can have as many instances of the custom component on their page as they wish. In the subscribe form example, we could use the tag <subscribe-form></subscribe-form> in multiple locations on the page. Of course, if you are doing this, you need to ensure that the beautiful component you have crafted is extremely flexible and will work across a range of devices and screen sizes.

Turning These Bad Boys Into Responsive Web Components

I feel the best way to demonstrate is by example, so I’ll continue with the subscribe form which is a common piece of UI that doesn’t change much between different sites and implementations.

Here’s one I made earlier:

Inside my Web Component template I have some basic markup for the form.

[code language="html"]
<ul class="form">
<li class="form__item">
<label for="name">Name:</label>
<input id="name" name="name" type="text">
</li>
<li class="form__item">
<label for="name">Email:</label>
<input id="name" name="name" type="text">
</li>
</ul>
[/code]

My markup and CSS are tucked away inside my component making use of the Shadow DOM part of the specification. This gives me encapsulation, allowing me to use label and input selectors freely in my code without worry of other styles bleeding in or mine bleeding out into the parent site.

For clarity and brevity, I’m not going to write out the styles other than ones used for layout. I’ve used a combination of float: left and display: table to achieve this layout to prevent breaking in any widths.

[code language="css"]
.form__item {
display: table;
float: left;
width: 50%;
}

label {
display: table-cell;
width: auto;
}

input {
display: table-cell;
width: 100%;
}
[/code]

I'll be using HTML imports to pull it into the SitePoint site as a demonstration:

Now we’re all set up, let’s look at some responsive techniques.

Continue reading %How You Can Use Responsive Web Components Today%

by David Berner via SitePoint