I\\\’m Vijith Dubai based UI/UX Designer and Front-End Developer.
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
Friday, March 31, 2017
VijithUI Designer
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
Cogesim General Contractor
Cogesim specialises in the creation, management and design of luxury retail products and private high-profile projects.
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
Rstyle Design
Portfolio website for Boston freelance web designer Chris Roberts
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
Photograper Hiroshi Ohno
Hiroshi Ohno is a photographer based in Osaka, Japan.
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
UI UX Designer
‘m a freelance UI UX Designer. Having an experience more than 10 years, focused on crafting clean & user friendly experiences. I enjoy turning complex problems into simple, beautiful and intuitive interface designs. In a nutshell I am problem solver
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
Your 2017 Guide To Email Etiquette (infographic)
Working in digital marketing, your job requires you to send countless emails every day as you negotiate with clients and attempt to spread the good word. Yet, if the public-facing aspect of your work is mostly made up of social media, online ads, and bulk emailing, you may be neglecting to tune up...
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Irfan Ahmad via Digital Information World
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Irfan Ahmad via Digital Information World
How to Synchronize WordPress Live and Development Databases
Developing WordPress themes is considerably easier with real content. Unexpected situations begin to arise when people add pages, posts, media and comments. Your beautiful template can break when:
- editors use assets which are too big or small for your breakpoints to handle
- managers introduce a new menu item which doesn't fit at lower screen sizes
- your theme implements a two-level menu hierarchy which fails to cater for the inevitable third-level page
- long or deeply-nested comments become unreadable.
Ideally, your development server should have a snapshot of your live production server's database. Your workflow can be improved further if content is automatically synchronized when changes occur.
Synchronization Snags
One-way WordPress database replication can be more challenging than you expect. There are good reasons why few coders live in this development dreamland…
Continue reading %How to Synchronize WordPress Live and Development Databases%
by Craig Buckler via SitePoint
How to create a long-scrolling Landing Page using Squarespace [video]
In this video tutorial I cover exactly how to create a long-scrolling Landing Page, for any business, using Squarespace. I go through adding page sections, content creation and fine tuning styles. Hope you find value in the video!
One Page Love Exclusive Coupon
OPL10
Squarespace has been kind enough to give One Page Love readers the exclusive coupon OPL10 for 10% Off your first website or domain purchase. (There is a free 14-day trial with no credit card needed, so you can try risk free.)
Chapters:
- Intro
- Starting with the Pacific Template
- Adding an intro header with centered logo
- Section: About
- Section: Image Gallery
- Section: Team
- Section: Testimonials
- Section: Contact & Map
- Design Tweaks
- Bonus: creating the logo
by Rob Hope via One Page Love
Top Resources to Get Started with Java 9
You can tell that Java 9 draws near because the number of posts and talks about it skyrocketed in the recent months. I want to recommend existing talks and articles where you can learn about Java 9 but also further resources, where new, high-quality content will pop up.
Talks
If you're the kind of person who likes to watch talks, there are quite a few I can recommend. For a great high-level overview and conceptual intro to the module system, watch Java 9: Make Way for Modules! (Mark Reinhold; 40 min). Going deeper into the module system, the JDK team has an entire series of talks:
- Introduction to Modular Development (Alan Bateman; 55 min)
- Advanced Modular Development (Mark Reinhold, Alan Bateman; 60 min)
- Project Jigsaw: Under The Hood (Mark Reinhold; 60 min)
As a follow-up, there was an Ask the Architect session at JFokus where Mark Reinhold answers all kinds of questions, among them some about Java 9 (transitive dependencies, version conflicts, state of JavaFX, ahead-of-time compilation; 23 min).
With Java 9 coming closer, people started presenting on non-modularity features that Java 9 has to offer. This is me talking a little bit about the module system before going into the new language features, a few new APIs (collection factories, reactive streams aka Flow API, stack-walking, multi-release JARs) and performance (50 min). If you want to dive deeper, there is a talk by Aleksey Shipilëv on compact strings and indified string concatenation, which I highly recommend (60 min). Monica Beckwith explains about G1 but be warned, you better have your GC expertise down before giving this a try (55 min).
There are also a number of great talks that are much more practical. To learn about how Maven deals with with Java 9, watch Robert Scholte talk about Unicode encoding, version strings, cross compilation, multi-release JARS, and then of course Jigsaw with its impact on how Maven works but also what it has to offer (50 min). Don't miss live-coding queen Trisha Gee working on a Java 9 project with IntelliJ, where she demonstrates various features of both the JVM and the IDE (30 min). If you're interested to see what a migration to Java 9 modules might look like, watch Rabea Gransberger live-refactor a small demo project (15 min). Of course there is no way to talk about live-coding without mentioning Venkat Subramaniam, who shows off modules and JShell in a mammoth 150 minute live session.
For shorter bits there are a couple of interviews the Voxxed folks recorded:
- Mark Reinhold talks about strong encapsulation, open modules, compatibility, and
sun.misc.Unsafe(10 min). - Venkat Subramaniam talks about compatibility, the Flow API, and wishes for future Java versions (13 min).
- I talk about migration and command line escapes (not yet the new
--permit-illegal-access, though) (7 min)
Articles
Continue reading %Top Resources to Get Started with Java 9%
by Nicolai Parlog via SitePoint
The Ultimate Guide to Choosing a Hosting Provider
This article is part of a series created in partnership with SiteGround. Thank you for supporting the partners who make SitePoint possible.
You need a website. You have a clear idea of what you want, and have carefully considered the type of hosting you need. Now, with credit card in hand, it’s time to decide which company to sign up with.
Choosing a hosting provider is one of the most crucial decisions you’ll make. The future of your website depends on it.
If you were looking for a babysitting service for your children, you wouldn’t just pick the cheapest option that came along. “Leave your kids with us for just 50c a day. Pick them up whenever.” Your kids mean more to you than that. You’d want to make sure they were safe, and being looked after by people who know what they’re doing. Saving money isn’t your priority; investing in their well-being is.
Invest some time up front in the future well-being of your website. Who should you pay to host your website? What are the qualities you need in a hosting company?
Here are six key criteria to consider when weighing up the options.
1. Speed & Performance
Do you remember the last time you bought a new laptop? You immediately noticed the improvement in performance, and the old one suddenly felt surprisingly slow. Fast is good. You want a hosting company with the equivalent of a new laptop.
First impressions are everything. You don’t want new visitors to your site to leave before your home page loads. How committed is the hosting company to performance? It requires an ongoing investment in both hardware and software.
It’s not always easy to tell how often a company upgrades its hardware, or how much money they invest in it. Here are some ways you might find out:
Continue reading %The Ultimate Guide to Choosing a Hosting Provider%
by Adrian Try via SitePoint
Procedurally Generated Game Terrain with ReactJS, PHP, and Websockets
Last time, I began telling you the story of how I wanted to make a game. I described how I set up the async PHP server, the Laravel Mix build chain, the ReactJS front-end, and the Web Sockets connecting all this together. Now, let me tell you about what happened when I starting building the game mechanics with this mix of ReactJS, PHP, and Websockets...
The code for this part can be found at: http://ift.tt/2mVNk1y. I've tested it with PHP 7.1 and in a recent version of Google Chrome.
Making A Farm
"Let's start simple. We have a 10 by 10 grid of tiles, filled with randomly generated stuff."
I decided to represent the farm as a Farm, and each tile as a Patch:
namespace App\Model;
class Farm
{
private $width
{
get { return $this->width; }
}
private $height
{
get { return $this->height; }
}
public function __construct(int $width = 10,
int $height = 10)
{
$this->width = $width;
$this->height = $height;
}
}
This is from
app/Model/FarmModel.pre
I thought it would be a fun time to try out the class accessors macro by declaring private properties with public getters. For this I had to install pre/class-accessors (via composer require).
I then changed the socket code to allow for new farms to be created on request:
namespace App\Socket;
use Aerys\Request;
use Aerys\Response;
use Aerys\Websocket;
use Aerys\Websocket\Endpoint;
use Aerys\Websocket\Message;
use App\Model\FarmModel;
class GameSocket implements Websocket
{
private $farms = [];
public function onData(int $clientId,
Message $message)
{
$body = yield $message;
if ($body === "new-farm") {
$farm = new FarmModel();
$payload = json_encode([
"farm" => [
"width" => $farm->width,
"height" => $farm->height,
],
]);
yield $this->endpoint->send(
$payload, $clientId
);
$this->farms[$clientId] = $farm;
}
}
public function onClose(int $clientId,
int $code, string $reason)
{
unset($this->connections[$clientId]);
unset($this->farms[$clientId]);
}
// ...
}
This is from
app/Socket/GameSocket.pre
I noticed how similar this GameSocket was to the previous one I had; except instead of broadcasting an echo I was checking for new-farm and sending a message back only to the client that had asked.
"Perhaps it's a good time to get less generic with the ReactJS code. I'm going to rename component.jsx to farm.jsx."
import React from "react"
class Farm extends React.Component
{
componentWillMount()
{
this.socket = new WebSocket(
"ws://127.0.0.1:8080/ws"
)
this.socket.addEventListener(
"message", this.onMessage
)
// DEBUG
this.socket.addEventListener("open", () => {
this.socket.send("new-farm")
})
}
}
export default Farm
This is from
assets/js/farm.jsx
In fact, the only other thing I changed was sending new-farm instead of hello world. Everything else was the same. I did have to change the app.jsx code though:
import React from "react"
import ReactDOM from "react-dom"
import Farm from "./farm"
ReactDOM.render(
<Farm />,
document.querySelector(".app")
)
This is from
assets/js/app.jsx
It was far from where I needed to be, but using these changes I could see the class accessors in action, as well as prototype a kind of request/response pattern for future Web Socket interactions. I opened the console, and saw {"farm":{"width":10,"height":10}}.
"Great!"
Then I created a Patch class to represent each tile. I figured this was where a lot of the game's logic would happen:
namespace App\Model;
class PatchModel
{
private $x
{
get { return $this->x; }
}
private $y
{
get { return $this->y; }
}
public function __construct(int $x, int $y)
{
$this->x = $x;
$this->y = $y;
}
}
This is from
app/Model/PatchModel.pre
I'd need to create as many patches as there are spaces in a new Farm. I could do this as part of FarmModel construction:
namespace App\Model;
class FarmModel
{
private $width
{
get { return $this->width; }
}
private $height
{
get { return $this->height; }
}
private $patches
{
get { return $this->patches; }
}
public function __construct($width = 10, $height = 10)
{
$this->width = $width;
$this->height = $height;
$this->createPatches();
}
private function createPatches()
{
for ($i = 0; $i < $this->width; $i++) {
$this->patches[$i] = [];
for ($j = 0; $j < $this->height; $j++) {
$this->patches[$i][$j] =
new PatchModel($i, $j);
}
}
}
}
This is from
app/Model/FarmModel.pre
For each cell I created a new PatchModel object. These were pretty simple to begin with, but they needed an element of randomness. A way to grow trees, weeds, flowers; at least to begin with:
public function start(int $width, int $height,
array $patches)
{
if (!$this->started && random_int(0, 10) > 7) {
$this->started = true;
return true;
}
return false;
}
This is from
app/Model/PatchModel.pre
I thought I'd begin just by randomly growing a patch. This didn't change the external state of the patch, but it did give me a way to test how they were started by the farm:
namespace App\Model;
use Amp;
use Amp\Coroutine;
use Closure;
class FarmModel
{
private $onGrowth
{
get { return $this->onGrowth; }
}
private $patches
{
get { return $this->patches; }
}
public function __construct(int $width = 10,
int $height = 10, Closure $onGrowth)
{
$this->width = $width;
$this->height = $height;
$this->onGrowth = $onGrowth;
}
public async function createPatches()
{
$patches = [];
for ($i = 0; $i < $this->width; $i++) {
$this->patches[$i] = [];
for ($j = 0; $j < $this->height; $j++) {
$this->patches[$i][$j] = $patches[] =
new PatchModel($i, $j);
}
}
foreach ($patches as $patch) {
$growth = $patch->start(
$this->width,
$this->height,
$this->patches
);
if ($growth) {
$closure = $this->onGrowth;
$result = $closure($patch);
if ($result instanceof Coroutine) {
yield $result;
}
}
}
}
// ...
}
This is from
app/Model/FarmModel.pre
There was a lot going on here. For starters, I introduced an async function keyword using a macro. You see, Amp handles the yield keyword by resolving Promises. More to the point: when Amp sees the yield keyword, it assumes what is being yielded is a Coroutine (in most cases).
Continue reading %Procedurally Generated Game Terrain with ReactJS, PHP, and Websockets%
by Christopher Pitt via SitePoint
P22 Studio
by via Awwwards - Sites of the day
Google Analytics: How to Analyze the Behavior of Your Site Visitors
Do you want to learn more about how people use your website? Wondering how the Behavior reports in Google Analytics can help? To explore how to navigate the Behavior section of Google Analytics, I interview Andy Crestodina. More About This Show The Social Media Marketing podcast is an on-demand talk radio show from Social Media [...]
This post Google Analytics: How to Analyze the Behavior of Your Site Visitors first appeared on .
- Your Guide to the Social Media Jungle
by Michael Stelzner via
Five Qualities of a Mature Design Culture
Throughout your career as a designer, you’ll work for many organisations, each with varying levels of design maturity. It’s important to enjoy the time spent at each of them, and pick up great experiences along the way.
For many designers, culture is a driving factor in choosing a company to work for and build a career. Design culture is more than ping pong tables, free food and a pretty workspace. It’s about providing the tools and an environment to perform at your best.
When evaluating the maturity level of the design culture of an organisation, some questions you might like to ask are:
- Is design positioned within the company as you would expect it to be?
- Are decisions being made without design having a seat at the table?
- Do most of the projects get buy-in from the organisation when they are started by non-design functions?
- Is design being brought in as a last-minute box to check before a product is launched?
- Is the UX team the only advocate for the user, while the rest of the organisation believes that they can just release a product and everyone will buy it?
- Are outside vendors and agencies championed as experts more than the internal team, who are just as capable?
- Are designers scattered throughout the teams, hidden in a dark corner somewhere feasting on scraps whenever the business decides to throw them a bone?
No matter the level of design maturity, each organisation has unique cultural strengths and areas that can be improved. While cultures and their individual fit may vary, these are five qualities to identify a mature design culture.
-
Design is represented at the executive level
Whether you have a Chief Design Officer, or a design level VP, you need to have executive support for design at the highest possible level. This role shows an organisational commitment to design both financially and philosophically. There is no longer a need for the justification of design, it is positioned as a function that’s integral to innovation and future success.
-
A common vocabulary
A mature design culture recognises that design is not the centre of the corporate universe. Having a shared vision and vocabulary among stakeholders with competing priorities and different backgrounds means there is no longer a need to translate design language or business acronyms.
The business manager is worried about profits, the marketing manager about brand, so leave the design lingo behind to clearly communicate solutions in terms universally understood. A common vocabulary allows everyone to be on the same page, speaking the same language.
-
Meaningful projects
One of the main things designers look for in an organisation is the quality of projects they’ll be working on. It doesn’t matter how fun or exciting a project is, if it never sees the light of day it’s considered throw away work.
The last thing the world needs is another weather app…
Everyone wants to work on projects that make a difference. The last thing the world needs is another weather app – there are plenty of good ones already. Mature design cultures aren’t afraid to kill a project from time to time and refocus the learning and efforts into another solution.
-
Design efficiency
Reinventing the wheel is not efficient. It’s also not fun for designers or developers to continually recreate the same elements for every project. Organisations should have efficiencies in place for design activities and collaboration.
Depending on maturity level, these can range from individual elements like such as research method cards, a style guide or a workshop playbook to a full-blown design system comprised of a design language or pattern library with working components. The design activities and processes shouldn’t compete with business processes. Instead, they should be fully integrated into one single process.
-
Talented people
The best teams are comprised of individuals who continually learn from one other.
Companies with a more mature culture have less turnover. While culture may attract talent, it’s the talent that keeps the culture evolving. The ideal team would be high-performing, comprised of individuals who continually learn from one other. It’s the best team you’ve ever worked for, one that shares accountability and pushes the other members to grow and succeed.
Culture can’t be forced. It has to come together organically through the continuous evolution of a team as a result of growing in size and experience. The way to cultivate culture is to influence others by putting in the work, building relationships, fostering collaboration, having uncomfortable conversations, making tough decisions, being accountable and influencing others by learning from mistakes and leading by example.
What culture do you look for in a workplace? Let us know in the comments or the forums.
During March, we’ve looked at how to better engage with stakeholders. Catch up on our latest posts:
- Using A/B Testing to Drive Constructive Conflict with Stakeholders
- Proven Strategies to Win Over Stakeholders for Your UX Project
- What’s the Impact of Investing in UX?
- Ego and Evidence Drive Designs, but Which One is Right?
- Doing Strategy to People
The post Five Qualities of a Mature Design Culture appeared first on UX Mastery.
by Andy Vitale via UX Mastery
Taking Steps towards Scrum
The following is an extract from our book, Scrum: Novice to Ninja, written by M. David Green. Copies are sold in stores worldwide, or you can buy it in ebook form here.
For most of this book, we've been talking about the practicalities of scrum. Although the core definition of scrum is very versatile—supporting a wide range of applications—we've gone into a fairly opinionated and detailed explanation of the mechanics of scrum as it can be applied in web and mobile teams. (Many of these principles and practices, however, apply just as well to other kinds of development work.)
Now that we have some shared vocabulary and concepts, in this chapter we're going to discuss how to get a team started with scrum. We'll go into more detail about the arguments for scrum when doing web and mobile development. We'll discuss what scrum is best for, how it compares to the alternatives, and provide answers to some of the questions that come up when making the case for scrum and applying it in a company.
Continue reading %Taking Steps towards Scrum%
by M. David Green via SitePoint
Thursday, March 30, 2017
Writing Better JavaScript with Flow
How often have you found yourself tracking down a bug in some code, only to find the error was something simple that should have been avoidable? Maybe you passed the arguments to a function in the wrong order, or perhaps you tried to pass a string instead of a number? JavaScript's weak typing system and willingness to try to coerce variables into different types can be a source of a whole class of bugs that just don't exist in statically typed languages.
March 30th, 2017: The article was updated to reflect changes to the Flow library.
Flow is a static type checker for JavaScript first introduced by Facebook at the Scale Conference in 2014. It was conceived with a goal of finding type errors in JavaScript code, often without having to modify our actual code, hence consuming little effort from the programmer. At the same time, it also adds additional syntax to JavaScript that provides more control to the developers.
In this article, I'll introduce you to Flow and it's main features. We'll look at how to set it up, how to add type annotations to your code, and how to automatically strip out those annotations when running the code.
Installation
Flow currently works on Mac OS X, Linux (64-bit) and Windows (64-bit). The easiest way to install it is via npm:
npm install --save-dev flow-bin
and add it to your project's package.json file, under the scripts section:
"scripts": {
"flow": "flow"
}
Once this is done, we’re ready to go ahead and explore its features.
Getting Started
A configuration file named .flowconfig must be present at the root of the project folder. We can create an empty config file by running the command:
npm run flow init
Once the config file is present, you can run ad-hoc checks on the code within your project folder and any subfolders by running the following command at the terminal:
npm run flow check
However, this is not the most efficient way to use Flow since it causes Flow itself to recheck the entire project's file structure every time. We can use the Flow server, instead.
The Flow server checks the file incrementally which means that it only checks the part that has changed. The server can be started by running on the terminal the command npm run flow.
The first time you run this command, the server will start and show the initial test results. This allows for a much faster and incremental workflow. Every time you want to know the test results, run flow on the terminal. After you're done with your coding session, you can stop the server using npm run flow stop.
Flow's type checking is opt-in. This means that you don't need to check all your code at once. You can select the files you want to check and Flow will do the job for you. This selection is done by adding @flow as a comment at the top of any JavaScript files you want to be checked by Flow:
/*@flow*/
This helps a lot when you're trying to integrate Flow into an existing project as you can choose the files that you want to check one by one and resolve any errors.
Type Inference
Generally, type checking can be done in two ways:
- Via annotations: We specify the types we expect as part of the code, and the type checker evaluates the code based on those expectations
- Via code inference: The tool is smart enough to infer the expected types by looking at the context in which variables are used and checks the code based on that
With annotations, we have to write some extra code which is only useful during development and is stripped off from the final JavaScript build that will be loaded by the browser. This requires a bit of extra work upfront to make the code checkable by adding those extra type annotations.
In the second case, the code is already ready for being tested without any modification, hence minimizing the programmer's effort. It doesn't force you to change how you code as it automatically deduces the data type of the expressions. This is known as type inference and is one of the most important features of Flow.
To illustrate this feature, we can take the below code as an example:
/*@flow*/
function foo(x) {
return x.split(' ');
}
foo(34);
This code will give an error on the terminal when you run the npm run flow command, as the function foo() expects a string while we have passed a number as an argument.
The error will look something like this:
index.js:4
4: return x.split(' ');
^^^^^ property `split`. Property not found in
4: return x.split(' ');
^ Number
It clearly states the location and the cause of the error. As soon as we change the argument from a number to any string, as shown in the following snippet, the error will disappear.
/*@flow*/
function foo(x) {
return x.split(' ');
};
foo('Hello World!');
As I said, the above code won't give any errors. What we can see here is that Flow understands that the split() method is only applicable to a string, so it expects x to be a string.
Nullable Types
Flow treats null in a different way compared to other type systems. It doesn't ignore null, thus it prevents errors that may crash the application where null is passed instead of some other valid types.
Consider the following code:
/*@flow*/
function stringLength (str) {
return str.length;
}
var length = stringLength(null);
In the above case, Flow will throw an error. To fix this, we'll have to handle null separately as shown below:
Continue reading %Writing Better JavaScript with Flow%
by Nilson Jacques via SitePoint
This week's JavaScript news, issue 328
|
by via JavaScript Weekly
CSS Viewport Units: A Quick Start
Thank you to Dave Maxwell and Ralph Masonfor having reviewed this article.
It has been a few years since viewport units were first introduced in CSS. They are truly responsive length units in the sense that their value changes every time the browser resizes. If you have heard about these units before but never learned about them in detail, this article can help you out.
The Units and Their Meaning
There are four viewport based units in CSS. These are vh, vw, vmin and vmax.
- Viewport Height (vh) — This unit is based on the height of the viewport. A value of
1vhis equal to 1% of the viewport height. - Viewport Width (vw) — This unit is based on the width of the viewport. A value of
1vwis equal to 1% of the viewport width. - Viewport Minimum (vmin) — This unit is based on the smaller dimension of the viewport. If the viewport height is smaller than the width, the value of
1vminwill be equal to 1% of the viewport height. Similarly, if the viewport width is smaller than the height, the value of1vminwill be equal to 1% of the viewport width. - Viewport Maximum (vmax) — This unit is based on the larger dimension of the viewport. If the viewport height is larger than the width, the value of
1vmaxwill be equal to 1% of viewport height. Similarly, if the viewport width is larger than the height, the value of1vmaxwill be equal to 1% of hte viewport width.
Let's see what the value of these units will be in different situations:
- If the viewport is 1200px wide and 1000px high, the value of
10vwwill be 120px and the value of10vhwill be 100px. Since the width of the viewport is greater than its height, the value of10vmaxwill be 120px and the value of10vminwill be 100px. - If the device is now rotated so that the viewport becomes 1000px wide and 1200px high, the value of
10vhwill be 120px and the value of10vwwill be 100px. Interestingly, the value of10vmaxwill still be 120px because it will now be determined based on the height of the viewport. Similarly, the value of10vminwill still be 100px. - If you resize the browser window so that the viewport becomes 1000px wide and 800px high, the value of
10vhwill become 80px and the value of10vwwill become 100px. Similarly, the value of10vmaxwill become 100px and the value of10vminwill become 80px.
At this point, viewport units may sound similar to percentages. However, they are very different. In the case of percentages, the width or height of the child element is determined with respect to its parent. Here is an example:
See the Pen Viewport Units and Percentage by SitePoint (@SitePoint) on CodePen.
As you can see, the width of the first child element is set to be equal to 80% of its parent's width. However, the second child element has a width of 80vw, which makes it wider than its parent.
Applications of Viewport Units
Since these units are based on viewport dimensions, it is very convenient to use them in situations where the width, height or size of elements needs to be set relative to the viewport.
Continue reading %CSS Viewport Units: A Quick Start%
by Asha Laxmi via SitePoint
How Can I Use Laravel Envoyer or Deployer with SemaphoreCI?
Test automation, continuous integration, and continuous delivery are quite widespread in the community now. This brought to life multiple services trying to make the process more enjoyable and less overwhelming for developers, so they can focus on delivering software instead of building/configuring tools to do that. One of those services is SemaphoreCI.
In this article, we're going to cover how to use our own deploy scripts and tools to continue the deployment process after a successful test.
We will be using SemaphoreCI for continuous delivery and Deployer to push our code to the DigitalOcean production server. If you're not familiar with Deployer, we recommend you check out this introduction.
Demo Application
We'll be using a 500px application that loads photos from the marketplace. It was built using Laravel and you can read the full article about its building process here, and find the repo on GitHub.
Creating a Deployer Script
The way Deployer works is by us defining servers, and then creating tasks that handle the process of deploying the application to those servers. Our deploy.php script looks like this:
<?php
require_once "recipe/common.php";
set('ssh_type', 'native');
set('default_stage', 'staging');
env('deploy_path', '/var/www');
env('composer_options', 'install --no-dev --prefer-dist --optimize-autoloader --no-progress --no-interaction');
set('copy_dirs', [
'app/commands',
'app/config',
'app/controllers',
'app/database',
'app/lang',
'app/models',
'app/src',
'app/start',
'app/tests',
'app/views',
'app/filters.php',
'app/routes.php',
'bootstrap',
'public',
'composer.json',
'composer.lock',
'artisan',
'.env',
]);
set('shared_dirs', [
'app/storage/cache',
'app/storage/logs',
'app/storage/meta',
'app/storage/sessions',
'app/storage/views',
]);
set('writable_dirs', get('shared_dirs'));
set('http_user', 'www-data');
server('digitalocean', '174.138.78.215')
->identityFile()
->user('root')
->stage('staging');
task('deploy:upload', function() {
$files = get('copy_dirs');
$releasePath = env('release_path');
foreach ($files as $file)
{
upload($file, "{$releasePath}/{$file}");
}
});
task('deploy:staging', [
'deploy:prepare',
'deploy:release',
'deploy:upload',
'deploy:shared',
'deploy:writable',
'deploy:symlink',
'deploy:vendors',
'current',// print current release number
])->desc('Deploy application to staging.');
after('deploy:staging', 'success');
You should read the Deployer article if you'd like to learn more about what this specific script does. Our next step is to set up a SemaphoreCI project. Please read the crash course article if you've never tried SemaphoreCI before, and do that.
Continue reading %How Can I Use Laravel Envoyer or Deployer with SemaphoreCI?%
by Younes Rafie via SitePoint
Hestia Pro
'Hestia Pro' is a powerful One Page WordPress theme suited for a digital agency or service business. Features include intro slideshow, services section (with video embed), team, pricing table, testimonials, newsletter sign up box, blog feed, Twitter Feed, Instagram Feed and a contact form. This is a solid follow up One Page theme by ThemeIsle to their hugely popular Zerif Lite WordPress theme. Note the $99 Price Tag is for full club membership with 20+ themes and 3 domain licenses - huge value.
There is also a Free Version of Hestia with reduced features to give the theme a real go before buying.
There is also a Free Version of Hestia with reduced features to give the theme a real go before buying.
by Rob Hope via One Page Love
Active Collab: How Collaboration Should Have Been All Along
This article was sponsored by Active Collab. Thank you for supporting the partners who make SitePoint possible.
Collaboration differs from team to team. All teams eventually discover their own unique workflow, although the way in which teams implement those workflows is fundamentally similar. Let's take file uploads as an example. Designers will upload their designs, writers will upload their writings. Regardless of what the team does, it’s a safe bet that they’ll use file uploads.
It doesn’t matter if you’re a designer, a writer, a marketer, or whatever: the best collaboration tools are those that master the core features — task management → feedback → time-tracking → invoicing. Enter Active Collab.
Powerful yet simple, Active Collab helps your team stay organized when you outgrow email, allowing you to manage tasks effectively, collaborate alongside your clients and delegate when necessary — think Trello, but with calendars, time-tracking and invoicing features built right in.
All Features in One Place
Whatever your team does, Active Collab has your back, allowing you to manage tasks from conception to completion. After estimating, time-tracking and collaborating on tasks, you can then issue invoices to clients when the tasks are complete — all in a single app. Project management works best when these features work cohesively, reducing (or even outright removing) friction which normally occurs when the required functionality is spread far and wide across various apps. With Active Collab, all of the management tools are united under one subscription.
A seamless experience is a happy (and productive) experience!
Task Management
Run your business like a well-oiled machine. Stay organised start to finish with advanced to-do lists, and manage your team’s progress every step of the way. While Active Collab has all the functionality you’ll ever need — time and expense tracking, file uploads, discussions and more — team members will only see what they need to see with their own unique dashboard.
Team Collaboration
Collaboration simply doesn’t work without communication. Luckily, Active Collab helps teams connect with @mention functionality, collaborative writing tools, and an easy-to-read calendar that ensures that you’ll never miss a deadline.
It’s time to ditch email. Active Collab ensures that your messages are treated as actionable tasks with due dates, and not inbox items that become weighted down and lost by mid-afternoon.
Time Tracking
With Active Collab, you can set hourly rates for the different types of work that your team does, and have the Active Collab Timer app record your hours automatically. While you focus on the task at hand, Active Collab does the rest, leaving you with the peace of mind that clients are being billed accurately, and, of course, saving you from the hassle of having to track time manually (which, ironically, can be very time-consuming!)
Continue reading %Active Collab: How Collaboration Should Have Been All Along%
by Daniel Schwarz via SitePoint
6 Free Web-Based SVG Editors Compared
While SVG images may not be as common as our favorite bitmap formats like PNG or JPG, the advantages of vectors has more and more designers looking to bring them into their projects.
In the past, we’ve usually looked at desktop applications like Adobe Illustrator and Inkscape – but in 2017 you don’t have to leave your web browser to design in vectors. So, if you’re looking for a free SVG editor, these 6 free Web-based SVG editors are a good start.
1. Vectr
Vectr is a good choice for both beginners and more advanced SVG users. Its interface is neat and it doesn’t overwhelm with a gazillion of tools you never use. This is great for newcomers to vector illustration because you shouldn’t feel lost among all the tools you have no idea what to use for. It comes with some tutorials as well, so even if you are a total stranger to SVG, you still will be able to start using it quickly.
This doesn’t mean Vectr lacks features – it has all the basic stuff, such as shapes, text, layers, shadows, borders, backgrounds, etc. you need to create a basic image. It doesn’t have all the glory of a full-fledged desktop editor but for some quick designs and edits, it makes it. You can either start a new file from scratch or upload an existing image.
You might get frustrated when uploading more complex illustrations and maps to Vectr as we’ve found it doesn’t always handle them well. But for simpler SVGs – icons, logos and the like – it’s mostly fine.
If you feel the Web version doesn’t offer what you need, you can find more features in the desktop ones. Vectr is available for Windows, Mac, Linux, and Chromebook.
Perhaps the single coolest features Vectr offers is the provision of linkable URLs to your graphic. This means you could display your Vectr SVG artwork on an external WordPress, Medium, Tumblr or other sites that allows display of SVG but blocks upload SVG to their servers.
Vectr also offers the ability to share your graphic within a Vectr editor panel, allowing others to edit the graphic you supply. This mean you could, for instance, provide a logo in a template design that users could then customize to their own requirements.
To this end, Vectr have recently released version of the products as a WordPress plugin for Vectr.
2. RollApp
Unlike the other tools on the list, when you go to RollApp’s homepage, you don’t see the tool right away. The reason is that RollApp isn’t a single app, it’s a package of apps and their SVG editor is just one of these apps. It’s a great tool, though, because this is a browser-based version of Inkscape.
If you want to use RollApp, you need an account. You can either register a new account or login with Google, Facebook, Amazon – very handy because I really hate it to create thousands of new accounts just to see the app I am registering for isn’t what I need.
After you login, you will see the following:
Yep, it’s Inkscape in all its glory! No doubt, RollApp is the most feature-rich app on this list – you are practically using Inkscape in your browser! I didn’t compare it item by item but it looks very much they have ALL the features of Inkscape, such as layers, objects, text, path, filters, effects, extensions, etc.
Be aware that with larger files, it’s not too fast because you are performing the actions on their servers over the Internet. In short, if you want to edit large and complex stuff, RollApp might not be ideal, but for any other task beyond basic edits, this may the best Web-based editor out there.
3. BoxySVG
If you have been reading SitePoint, you probably already know about BoxySVG because we have covered BoxySVG quite a bit over the past 12 months. I am not going to review it in more detail because this BoxySVG review tells more than I can tell, so read it.
Importantly, BoxySVG has added a code inspector since Alex’s original review, making this one of the most relevant SVG tools for web developers.
4. Janvas
Janvas was a very popular SVG editor a couple of years ago. Unfortunately, it doesn’t seem under active development in recent years and even though it’s still working, as the Web moves forward and Janvas sits still, it’s becoming less of a choice. In fact, Alex from SitePoint used it quite a bit in 2013-14 (including the paid version) and was even answering some of the support questions on the Janvas Google+ for a while. Janvas was a powerful app.
The main problem with Janvas is that it’s not very up-to-date. As browsers evolve, apps that don’t evolve get a tiny bit buggier every day. Janvas has tons of features, including shapes, text, drawing tools, paths, masks, and layers but – as user report in the forums attest – many of these features don’t produce the desired results.
The encouraging news is that a new version is coming as a Chrome app. Let’s hope it fixes these issues.
5. DrawSVG
Maybe you’ve already found your free Web-based SVG editor among the apps so far but if you haven’t, here is more. DrawSVG is a fully standard compliant SVG editor with a lot of features. What I really like about it that it has the look and feel of a Web app – i.e. menu on the left, click to open submenu, etc. - rather than the look and feel of a desktop app ported for the Web.
With DrawSVG you can draw, modify, and render objects. This includes drawing basic shapes, Bezier curves, straight and curved text, numerous stroke and fill styles, etc. You can also export your SVG to PNG.
Continue reading %6 Free Web-Based SVG Editors Compared%
by Ada Ivanoff via SitePoint
Beer – Cory Gibbons
Single Serving One Pager providing a log of the unique beers consumed by designer, Cory Gibbons. Dare I say that's an awesome use of the .beer domain extension 
by Rob Hope via One Page Love
5 Ways to Improve Customer Retention With Social Media
Do you use social media to keep existing customers engaged with your business? Interested in effective ways to strengthen those relationships? Social media marketing can help deepen your connections with existing customers so they continue using your product or service. In this article, you’ll discover five ways to increase customer retention via social media. How [...]
This post 5 Ways to Improve Customer Retention With Social Media first appeared on .
- Your Guide to the Social Media Jungle
by Tamar Weinberg via
Polished – Lightweight Toolset for Writing Styles in JavaScript
Polished is a lightweight toolset for writing styles in JavaScript.
- Make your app look great without stress
- Cross framework compatible: No matter if you're using
styled-components, aphrodite, radium or plain inline styles, as long as you're writing your styles in JavaScript you can use polished! - Switching from a pre-processor to styles in JS made easy
by via jQuery-Plugins.net RSS Feed
Using A/B Testing to Drive Constructive Conflict with Stakeholders
“Tell me about a time when you disagreed with a coworker…” Hiring managers use questions like this to get a sense of how a job candidate will handle disagreements and work with others under difficult circumstances.
It’s a complicated topic for user experience, where ideas are assumptions to be validated and opinions are all on equal footing. In the business of measuring “better,” we’re expected to think critically and argue from reason.
If you’re lucky enough to work with an experienced and diverse group of people, opinions will vary and disagreements will be the norm. The problem is that fear of controversy can make people less likely to engage in the kinds of useful debates that lead to good designs.
Creating a culture of user experience involves asking uncomfortable questions; the key is to navigate that friction so that people feel encouraged not just to contribute but also to question ideas.
A/B testing is a good way to help teams separate concerns and learn to disagree constructively. Minutia gets sorted out quickly, the work moves forward, and most importantly you help create a framework for challenging ideas, not people.
A/B Testing is fast, good and cheap
Decisions aren’t always obvious, and you may not have the luxury of an executive decision-maker to break an impasse. More often than not, you have to work with people to rationalise a direction and find your way out of the weeds.
The exercise of running an A/B test can help disentangle design intent from mode of execution. When stakeholders see how easy it is to separate fact from fiction, there’s less fear of being wrong and ideas can flow and be rejected, developed or improved upon more freely.
Another perk of A/B testing is that platforms like Optimizely or VWO let you run experiments with live users on your website. “In the wild” testing give stakeholders a chance to see for themselves how their ideas stand to impact customer reality.
It’s now easier than ever to design and deploy low-risk A/B experiments, and there’s no excuse not to do it. But like any tool, A/B testing has its limitations – and no product has a warranty that protects against misuse.
Draws are boring, fans want KOs
What happens when an A/B test fails to deliver clear results?
A/B testing software is often marketed around dramatic examples that show impactful decisions made easy through testing. Stakeholders may be conditioned to think of testing in terms of winners and losers, and experiments that don’t produce clear outcomes can create more questions than answers:
“We A/B tested it, but there was no difference, so it was a waste…”
A lack of familiarity with the domain can lead to criticism of the method itself, rather than its use. This “carpenter blaming the tools” mentality can disrupt stakeholders’ ability to work harmoniously – and that is not the kind of conflict that is constructive.
The reality is that not every A/B test will yield an obvious winner, and this has partly to do with how experiments are designed. For better or worse, tools like VerifyApp now make it easy to design and deploy tests. Like anything else, it’s garbage in, garbage out – and there’s no sample size large enough to turn a noisy experiment into actionable insights.
Such heartburn is only made worse when teams undertake A/B testing without a clear sense of purpose. A/B tests that aren’t designed to answer questions defy consistent interpretation, and only add to the gridlock of subjective analysis.
As an example, I’ll use a topic which I think is well suited for A/B testing: call-to-action buttons.
Consider the following experiment between 2 versions of the same call-to-action. At a glance, the outcome may seem clear:
What makes this test result problematic is that there are multiple design-related differences (font weight, content, copy length, button colour) between A and B. So tactically, we know one approach may convert better, but we don’t really know why. Ultimately, this experiment asks the question:
“Which converts better?”
…and only narrows it down to at least 4 variables.
When you’re new to A/B testing, a few noisy experiments are a forgivable offence and you may find you get more traction by focusing on what stakeholders are doing right. Any testing is better than none, but habits form quickly, so it’s important to use early opportunities like this to coach people on how experimental design affects our ability to get answers.
Another reason pairwise experiments don’t always have clear “winners” is because sometimes, there’s just no difference. A statistical tie is not a sexy way to market A/B testing tools. Consider another hypothetical example:
Notice that there’s only 1 difference between A and B – the button text label. Is one version better than the other? Not really. It’s probably safe for us to conclude that, for the same experimental conditions, the choice between these 2 text labels doesn’t really impact conversion rate.
Does a stalemate make for a compelling narrative? Maybe not – but now we know something we didn’t before we conducted this anticlimactic experiment.
So while a tie can be a valid experimentally, it may not help defuse some of the emotionally charged debates that get waged over design details. That is why it’s so critical to approach A/B testing as a way to answer stakeholder questions.
Want good answers? Ask good questions
When the work is being pulled in different directions, A/B testing can deliver quick relief. The challenge is that the experiments are only as good as the questions are designed to answer.
With a little coaching, it’s not difficult to help teams rely less on subjective interpretation and wage more intelligent arguments that pit idea vs. idea. It falls on UX teams to champion critical thinking, and coach others on how to consider design ideas as cause-and-effect hypotheses:
Will the choice of call to action button colour impact conversion rates?
Does photograph-based vs. illustrated hero artwork impact ad engagement?
Is Museo Sans an easier font to read than Helvetica Neue?
The act of formulating experimental questions helps to reveal the design intent behind specific ideas, and cultivates a sense of service to project vs. individual goals. When stakeholders share an understanding of the intent, it’s easier to see they’re attacking the same problem different ways.
It’s also imperative to experiments simple, and the best way to do that is to focus on one question at a time.
Consider the button example from earlier, where we concluded that the choice of 2 text labels had little impact on conversion rates. To see what else might move this needle, we can try to manipulate another variable, such as button colour:
This experiment asks the question:
Will the choice of call to action button colour impact conversion rates?
There’s only 1 difference between A and B – button colour. Now, we not only have an answer we can use tactically, but strategically we have a good idea why one converts better than the other.
Summary
Stakeholders won’t always see eye to eye with each other, and that’s no reason to shy away from or stifle conflict. Good ideas benefit from scrutiny, and quick A/B experiments help get people get in the habit of asking tough questions. The answers lead to better tactical decisions, and help drive a culture of healthy debate.
A/B testing is just one tactic you can use within a strategy to win over stakeholders. If you want to help your team keep each other honest, try A/B testing as a first step towards creating a culture where co-workers feel more comfortable disagreeing as a means to a constructive end.
Do you have experience using A/B testing to drive conversations with stakeholders? Share your experience in the comments or the forums.
This month, we’ve been looking at stakeholder management. Catch up on our latest posts:
- Proven Strategies to Win Over Stakeholders for Your UX Project
- What’s the Impact of Investing in UX?
- Ego and Evidence Drive Designs, but Which One is Right?
- Doing Strategy to People
The post Using A/B Testing to Drive Constructive Conflict with Stakeholders appeared first on UX Mastery.
by Luke Smith via UX Mastery
B&O PLAY Spring/Summer 2017
by via Awwwards - Sites of the day
Let’s go to New York
Slick One Pager with clear typography promoting Tobias van Schneider's new eBook, Let's go to New York. Awesome to see the SendOwl integration for purchases, I'm a big fan of the service.
by Rob Hope via One Page Love
Debugging CSS for UI Responsiveness
The following is an extract from our book, CSS Master, written by Tiffany Brown. Copies are sold in stores worldwide, or you can buy it in ebook form here.
CSS properties and values that trigger reflows are particularly expensive. They can slow user interface responsiveness―page rendering, animation smoothness, and scroll performance―especially on low-powered devices such as phones and smart TVs.
Continue reading %Debugging CSS for UI Responsiveness%
by Tiffany Brown via SitePoint
Most Powerful Content Marketing Tips for the Success of Ecommerce Business
The recent surge in the global growth of eCommerce industry has made it one of the hottest destinations for the startups. Going by a recent study carried out by e-marketer, eCommerce retail sales in the world are expected to touch the figure of $2.5 trillion by the end of 2018. This positive trend...
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Guest Author via Digital Information World
[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]
by Guest Author via Digital Information World
Subscribe to:
Posts (Atom)