Top 5 Breakout Mobile Design Trends for 2016

If you want to enjoy a view from the front, you’re going to need to step up your mobile design.

Based on my conversations with the design team at UXPin, let’s deconstruct 5 useful mobile design trends for 2016.

1. Layered Interfaces

Obviously the biggest difference between desktop and mobile screens is the size. Mobile sites and apps have less room, plain and simple. To help neutralize this drawback, more and more interfaces are implementing multiple layers, one on top of the other.

These “stacked” interfaces, like a pile of papers, allow users to open, close, pull out, switch tabs, swipe away, interact outside of, or simply remove windows more freely. This setup conserves space with only one relevant window at a time, but with easy access to the rest.

Photo credit: Reddit App via Google Play

Some common applications of the layered interface include:

• Large drop-downs and drawers — A standard “hamburger menu” option for keeping all the common actions a user needs that aren’t immediately relevant on the opening screen.

• Sticky menus — A minimal menu with only the essentials that remains on the screen at all times while the user interacts with the fluid screens outside.

• **Tabs — **A digital version of the paper organizational method, with a small clickable area of different pages always visible.

• **Modals — **Just like with desktops, you can superimpose entire windows over existing ones to ensure they’re noticed, such as logins, ads, or reminders.

Layered interfaces work within the principles of Google’s Material Design, which mimics how people organize and interact documents in the real world. Shuffling papers around with the most important on top is something we do without even thinking.

TIP: Consider gradient shadows or full fade out on the secondary layers to accent the layered format. This acts as a visual cue for how users can interact with different levels.

2. Creative Gestures

Swiping and tapping are as instinctual as pointing and clicking by now. They touch screens have so much more potential usability than cursors — almost endless potential, depending on your creativity. To set your mobile site or app apart, you’ll need to to draw on this creativity.

Photo credit: Clear via Realmac

The next generation of gestures, which we call “complex gestures,” originate from gaming but are now infiltrating other interfaces. They typically follow a three-phase system:

1. **Initiation — **The action that triggers the sequence, usually a tap or hold.

2. Continuation — Stringing along other gestures, such as unique touch patterns or tapping, as simple or complicated as you think the user can handle.

3. Termination — Signalling the end of the interaction; could be merely stopping contact with the screen.

But a word of warning: Don’t reinvent the wheel, here. Creative gestures aren’t something that can be packed on — each one requires learnability and recall, and take the UI farther away from “intuitive.”

As explained in the free guide Mobile Design Trends 2016, only use a new gesture when they improve upon an old form of interacting, i.e., make it faster, more comfortable, or more natural. Otherwise, stay with what the user already knows. To paraphrase Mark Twain, “Don’t use a five-dollar gesture when a fifty-cent one will do.”

TIP:**_ _**Consider physical limitations when designing new gestures, especially the different ways users can hold a mobile device. Vertical or horizontal, one or both (or no) hands, thumbs or pointers. User research will reveal which your target users prefer.

3. Practical Microinteractions

Microinteractions started as delightful little flourishes that enhanced an interface’s enjoyability, but little else. The UI equivalent of colorful sprinkles. But now, designers are realizing that these tiny, often unnoticed moments can serve deeper and more practical purposes. In the future, we’ll see them utilized more and more.

Photo credit: Slack via iTunes

A microinteraction can be anything from a momentary animation to a cutesy sound effect. The nature of the microinteraction has flexibility, but how it’s used should follow some predefined guidelines if you want to make the most of it.

In Dan Saffer’s book Microinteractions, he outlines three useful purposes for microinteractions:

1. Communicate status

2. Visualize the the consequence of an action (instant feedback)

3. Influence what the user sees on the screen (points something out)

Using a microinteraction for any of the above reasons goes beyond mere enjoyability — it improves usability, learnability, and creates a more efficient functionality. In 2016, microinteractions will be used more and more to fill in the “cracks” of an interface.

TIP: The best microinteractions stay one step ahead of the user and almost predict what they’re thinking. Look for patterns in your user research to see which areas would benefit most with a little smoothing over. Microinteractions can be used at almost any point in a UI, so the question is less about what they are than where they are.

4. Meaningful Typography

The smaller the screen, the more meaningful the typography. Neglecting how your words are presenting on mobile devices — in other words, not changing the typography at all from the desktop version — creates a mobile site or app that’s hard to read and hard to use.

The trick with mobile typography is balancing legibility with space conservation. For this reason, simpler typefaces are often chosen, since they are easier to read at smaller sizes. Characteristics like sans serif and rounded edges also fit in with the aesthetic styles of minimalism and flat design, which are also trends of 2016.

Photo credit: Betterment via Google Play

Another concern is alignment, which tends to convolute layouts when confronted with unexpected breakpoints. Unfortunate alignment can lead to typographical faux paus like widows, orphans, and rags.

While there’s no failsafe way to deal with these completely, following the advice below will eliminate many of the problems:

• For large blocks of text, use a left alignment. This complements are natural reading rhythms when we dedicate ourselves to reading every word.

• For small bits of text, use a center alignment. For headlines and calls-to-action, a center alignment improves visibility and looks less awkward with hanging text.

Right alignment should only be used in a controlled setting, such as a single short title, or with forced breaks after each word.

TIP: To ensure legibility in mobile devices, aim for 30-40 characters per line. This conservative estimate is half of the recommended 60-75 characters for desktop, but keep in mind some readers may have sight disability, and the rest will appreciate the convenience.

5. Bite-Sized Cards

The card layout has already revolutionized both desktop and mobile browsing, so designers are exploring new ways to improve it. As time goes on, mobile cards are getting smaller, effortlessly transitioning into an offshoot of buttons.

Photo credit: Spotify via Google Play

Cards started as a way to organize a wealth of information into bite-sized doses so users can choose what they want to interact with or ignore. Social media giants like Facebook, Twitter, and especially Pinterest brought cards into the mainstream as a way to make sense of the otherwise chaotic mess of user-generated content.

The typical card format contains some or all of these common elements:

• Image

• Title

• Text description

• Control icons (Favorite, Like, Retweet, Download, etc.)

• Expand option

• Secondary description (author of content, date, etc.)

Continue reading %Top 5 Breakout Mobile Design Trends for 2016%

by Jerry Cao via SitePoint

The Repository Pattern in Laravel 5

The repository pattern was introduced for the first time by Eric Evans in his Domain-Driven Design book. The repository is, in fact, the entry point for the application to access the domain layer.

To put it simply, the repository allows all your code to use objects without having to know how the objects are persisted. The repository contains all the knowledge of persistence, including mapping from tables to objects. This provides a more object-oriented view of the persistence layer and makes the mapping code more encapsulated.

The only way to make your repositories work in Laravel (as a real repository—Eric Evans Domain-Driven Design book) is to change the default ORM from active record to data mapper. The best substitute is Doctrine.

The Doctrine ORM

Doctrine is an ORM (object-relational mapping) which implements the data mapper pattern and allows you to make a clean separation of the application’s business rules from the persistence layer of the database. Doctrine uses DQL, rather than SQL. DQL brings you object query language, meaning that instead of a traditional relational query term, you would have queries in object term.

It allows you to write the database queries in an object-oriented way and helps when you need to query the database in a way which can’t be achieved using the default repository methods. In my opinion, DQL is the most powerful way to keep in touch with your database.

Doctrine vs. Eloquent

Doctrine entities are just a plain PHP simple class and do not add overhead to any ORM inheritance. Doctrine manages your multiple query requests with the same inheritance without hitting the database, meaning the entity object exists for the entire request.

The other nice feature of Doctrine is that instead of migrating files to create the database schema, the database is automatically created to reflect the meta data in the entity annotations. On the other hand, Eloquent is less complicated and very easy to use.

A complete comparison between these two would necessitate a separate article. As you can see, a Doctrine object is lighter and more abstract. However, Doctrine will only fit specific projects, so it may bring you overhead at times. I believe it depends on the programmer to choose the best ORM for the app.

The Blog App

Now it’s time to create a blog app with Laravel. First, we need to set up Doctrine. There is a bridge to allow for matching with Laravel 5’s existing configuration. To install Doctrine 2 within our Laravel project, we run the following command:

composer require laravel-doctrine/orm

As usual, the package should be added to the app/config.php , as the service provider:

LaravelDoctrine\ORM\DoctrineServiceProvider::class,

The alias should also be configured:

'EntityManager' => LaravelDoctrine\ORM\Facades\EntityManager::class

Finally, we publish the package configuration with:

php artisan vendor:publish --tag="config"

Now we’re done here.

Entities are important parts of the app App\Entities\Post.php:

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="posts")
 * @ORM\HasLifecycleCallbacks()
 */
class Post
{
    /**
     * @var integer $id
     * @ORM\Column(name="id", type="integer", unique=true, nullable=false)
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     *
     */
    private $id;

    /**
     * @ORM\Column(type="string")
     */
    private $title;

    /**
     * @ORM\Column(type="text")
     */
    private $body;

    public function __construct($input)
    {
        $this->setTitle($input['title']);
        $this->setBody($input['body']);
    }

    public function setId($id)
    {
        return $this->id=$id;
    }

    public function getId()
    {
        return $this->id;
    }

    public function getTitle()
    {
        return $this->title;
    }

    public function setTitle($title)
    {
        $this->title = $title;
    }

    public function getBody()
    {
        return $this->body;
    }

    public function setBody($body)
    {
        $this->body = $body;
    }
}

Now it’s time to create the Repository, which was described earlier. App/Repositories/PostRepo.php :

namespace App\Repository;

use App\Entity\Post;
use Doctrine\ORM\EntityManager;
class PostRepo
{

    /**
     * @var string
     */
    private $class = 'App\Entity\Post';
    /**
     * @var EntityManager
     */
    private $em;


    public function __construct(EntityManager $em)
    {
        $this->em = $em;
    }


    public function create(Post $post)
    {
        $this->em->persist($post);
        $this->em->flush();
    }

    public function update(Post $post, $data)
    {
        $post->setTitle($data['title']);
        $post->setBody($data['body']);
        $this->em->persist($post);
        $this->em->flush();
    }

    public function PostOfId($id)
    {
        return $this->em->getRepository($this->class)->findOneBy([
            'id' => $id
        ]);
    }

    public function delete(Post $post)
    {
        $this->em->remove($post);
        $this->em->flush();
    }

    /**
     * create Post
     * @return Post
     */
    private function perpareData($data)
    {
        return new Post($data);
    }
}

The controller: App/Http/Controllers/PostController.php :

namespace App\Http\Controllers;
use App\Repository\PostRepo as repo;
use App\Validation\PostValidator;


class PostController extends Controller
{
    private $repo;

    public function __construct(repo $repo)
    {
        $this->repo = $repo;
    }

    public function edit($id=NULL)
    {
        return View('admin.edit')->with(['data' => $this->repo->postOfId($id)]);
    }

    public function editPost()
    {
        $all = Input::all();
        $validate = PostValidator::validate($all);
        if (!$validate->passes()) {
            return redirect()->back()->withInput()->withErrors($validate);
        }
        $Id = $this->repo->postOfId($all['id']);
        if (!is_null($Id)) {
            $this->repo->update($Id, $all);
            Session::flash('msg', 'edit success');
        } else {
            $this->repo->create($this->repo->perpare_data($all));
            Session::flash('msg', 'add success');
        }
        return redirect()->back();
    }

    public function retrieve()
    {
        return View('admin.index')->with(['Data' => $this->repo->retrieve()]);
    }

    public function delete()
    {
        $id = Input::get('id');
        $data = $this->repo->postOfId($id);
        if (!is_null($data)) {
            $this->repo->delete($data);
            Session::flash('msg', 'operation Success');
            return redirect()->back();
        } else {
            return redirect()->back()->withErrors('operationFails');
        }
    }
}

As you see, I’ve used the Flash helper to manage the messages (you can use Laravel’s). Regarding the Validator, I should add that you can create your own (as I do) or use the Laravel default, depending on your preference.

View files are the same as usual. In this sample view, the file seems like resources/views/admin/edit.blade.php :

<div class="panel-body">
  <div class="row" >
        <div class="col-md-12">
          @if (Session::has('flash_notification.message'))
            <div class="alert alert-{{ Session::get('flash_notification.level') }}">
                <button type="button" class="close" data-dismiss="alert" aria-hidden="true">&times;</button>
                {!! Session::get('flash_notification.message') !!}
            </div>
            @endif
            </div>
          </div>
                @if($errors->has())
                    <div class="alert alert-danger" role="danger" >
                        @foreach ($errors->all() as $error)
                            <ul>
                                <li>{!! $error !!}</li>
                            </ul>
                        @endforeach

                    </div>
                @endif
                <form method="post" >
                <div class="row">
                    <div class="col-md-6">
                        <div class="input-group {!! $errors->first('title')?'has-error':'' !!}">
                            <div class="input-group-addon">{!! 'title' !!}</div>
<input type="text" name="title" value="{!!  is_object($ListData)?$ListData->getBody():'' !!}" class ='form-control' autocomplete= 'off'  />
                        </div>
                        <span class="help-block">&nbsp;</span>
                    </div>
                    <div class="col-md-6">
                        <div class="input-group {!! $errors->first('body')?'has-error':'' !!}">
                            <div class="input-group-addon">{!! 'Body' !!}</div>
<textarea name="body" class ='form-control' autocomplete= 'off' > {!!  is_object($ListData)?$ListData->getTitle():'' !!} </textarea>

                        </div>
                        <span class="help-block">&nbsp;</span>
                    </div>
                </div>

                <div class="row">
                    <br/>
                    <div class="col-md-6">
                        <div class="col-sm-5 submitWrap">
                            <button type="submit" class="btn btn-primary btn-md" > {!! 'save' !!}</button>
                        </div>
                    </div>
                </div>
                </form>
            </div>
        </div>
    </div>

The routing and other operations would be as usual.

Conclusion

Now you see how you can easily create a repository based on Doctrine in Laravel 5.0, which will result in many benefits.

For those of you who are either just getting started with Laravel or looking to expand your knowledge, site, or application with extensions, we have a variety of things you can study in Envato Market.

by Alireza Rahmani Khalili via Envato Tuts+ Code

10 Leading Women in the Cocoa Community

Today is International Women's Day. Even though there shouldn't be a special day to celebrate women, I'd like to take the opportunity to put ten women in the spotlight that have a significant impact in the Cocoa community and beyond.

The Cocoa community has always been a very open and welcoming community and it is fantastic to see that anyone can thrive in this community. The women listed below have proven that anyone can excel in technology. No matter who you are, if you need that extra push to exceed your own expectations, then let these women inspire you on your journey.

Veronica Ray

Veronica, also known as @nerdonica on Twitter, currently works as a software engineer at LinkedIn. She started her career at Bizo, a startup focused on helping advertisers reach businesses and professionals, which LinkedIn acquired in 2014. That is how Veronica ended up at LinkedIn as a software engineer.

Veronica is actively involved in promoting diversity in the technology industry. She has mentored at Hackbright Academy, helping women become software engineers, and is a member of Double Union, a maker space for women in San Francisco.

Kristina Thai

Kristina is a passionate advocate for women in technology. At Intuit, she works as an iOS engineer and she also helped start Tech Women@Intuit. The Apple Watch is one of Kristina's personal passions and she frequently writes and talks about her explorations and discoveries. In a recent talk at Swift Summit San Francisco, she talked about creating compelling applications for watchOS. Kristina writes on her blog and tweets on Twitter.

Diana Zmuda

Diana is an iOS engineer at thoughtbot, a leading company in the mobile and web space. She works and lives in Portland and has co-authored a book about iOS development, iOS on Rails, with Jessie Young. Even though she graduated with a degree in math and economics, she changed course and is now developing mobile applications in Swift at thoughtbot.

As a Camp Lead Developer at App Camp for Girls, Diana helps girls become familiar with the technology industry. Over the course of one week, young women learn about designing and building software. They also dip their toes in the business aspect of software development and are given the opportunity to put their creativity to work.

Ayaka Nonaka

Ayaka has been developing for iOS since the early days of the platform and is currently living and working in Oakland as the iOS lead at Venmo, a platform for sharing payments. She was quick to adopt Swift and frequently talks about Apple's new programming language.

Last year, she gave an interesting talk about natural language processing with Swift in which she explains how to build a spam filter using naive Bayes classifiers. You can follow Ayaka on Twitter. She occasionally writes on her blog and Medium.

• Swift Scripting

• Natural Language Processing With Swift

Laura Savino

With a passion for human languages and a strong background in teaching and education, Khan Academy was a perfect fit for Laura. She accidentally came into contact with programming and started working at Ubermind as a mobile developer. Her mentor at Ubermind convinced her to develop for iOS, which eventually led to Laura being the first iOS developer at Khan Academy.

Like Diana Zmuda, Laura is involved in App Camp for Girls. She brings girls in Seattle in contact with software development, striving for gender equality in technology by offering engaging educational programs. Laura currently works as an independent developer and speaker. She frequently speaks at conferences, such as Çingleton, CocoaConf, and UIKonf.

• Çingleton 2014
• Localization! Because 영어 n'est pas 足够 por todo el mundo

Novall Khan

Novall currently works as an iOS engineer at Splitwise, a platform for splitting expenses with friends, and previously worked at ShapeUp and Willow Tree Apps. She started her career in academia, focusing on learning and memory among other topics. She is also the founder of Pink Chalk Labs, a non-profit organization for building applications in the mental health space. Novall frequently talks about Cocoa development. In the past, she has spoken at CocoaConf and, more recently, try! Swift. You can also find Novall on Twitter.

Stephanie Shupe

Stephanie is currently working as a senior software engineer at Lookout, a security company that focuses on predictive security. Through Women Who Code, Stephanie inspires women to start a career in technology. She first served as a board member and currently acts as an advisor for the non-profit.

Women Who Code, WWCode for short, is a non-profit organization that serves as a worldwide platform for women interested in technology. The goal is to bring diversity to the technology industry. The organization's credo is clear "The world of technology is much better with women in it." You can follow Stephanie on Twitter.

Michele Titolo

Michele is the CTO of Women Who Code and works as an iOS engineer at Capital One. She has been developing for the iOS platform since 2010 and has worked on dozens of projects since. Michele is a frequent speaker at conferences, such as AltConf and try! Swift. You can follow Michele on Twitter and read her musings on her blog.

• The Worst Code
• Swift Protocols and the Promised Land

Erica Sadun

If you are an active participant of the Swift community, then you probably already know Erica Sadun. Erica has been active in the Cocoa community since the early days of the iPhone. Having written more than a dozen books on various topics, it is safe to say Erica is a prolific writer.

Erica's blog is a must read if you want to stay up to date about Swift and Cocoa development. She is a very active participant of the Swift open source project and has already had a significant impact on the project's path. You can follow Erica on Twitter and don't forget to visit her blog.

Natasha Murashev

When Swift was announced in 2014, Natasha was immediately hooked. She has been writing about Apple's new programming language ever since and has become a frequent speaker at conferences and meetups.

Natasha is one of the organizers of the try! Swift conference and the woman behind This Week in Swift. Natasha, better known as Natasha The Robot, tweets on Twitter and writes on her blog, but make sure to check out some of her talks listed below.

• Swift Thinking
• The Functional Way

Conclusion

It goes without saying that this is only a selection of the women that are currently making a difference in technology. Which women do you look up to? Let us know in the comments below.

by Bart Jacobs via Envato Tuts+ Code

Save 70% on Lifetime Access to Premium WordPress Themes

With the right theme, your WordPress site can be anything from a company website to an e-commerce destination. Get a lifetime subscription to TeslaThemes WordPress Themes for $59 at SitePoint Shop.

You don’t need to hire a designer when you’ve got this Developer Plan at TeslaThemes. Their library’s already got 37 themes to choose from, with 24 new ones added every year. Choose from themes tailored to blogs, e-commerce, marketing, nonprofit causes, educational institutions, magazines, news sites, and more. You’ll get the full PSD file for every single theme, so you can customize it to your heart’s content.

Save on designer fees. Get a lifetime subscription to TeslaThemes WordPress Themes for $59 at SitePoint Shop.

Continue reading %Save 70% on Lifetime Access to Premium WordPress Themes%

by SitePoint Offers via SitePoint

How Welcoming are WordCamps to Women?

Hustle Panda

Some more shameless self-promotion but another One Pager shipped this year! Hustle Panda is a One Page website where you can buy a short brandable .com domain for your next startup. No numbers. No hyphens. No bidding. All domains are under $1000 and instantly securable. I’ve got a string of blog posts related to Hustle Panda (character, direction, marketplace, influences) rolling out in the next few weeks on my personal blog. It’s been such fun working on the cheeky Panda branding and copy. I’m trying to put a refreshing take on a very dirty domain-buying industry and really stoked with the outcome so far. Hope you dig it – please send any feedback what-so-ever! Cheers, Rob.

by Rob Hope via One Page Love

Showwwcase

Clean responsive One Pager promoting a design feedback tool called Showwwcase.

by Rob Hope via One Page Love