Archive for year: 2017

Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/d5KdA4ocA0M/industrial-design-introducing-fitbit-ionic

Industrial Design: Introducing Fitbit Ionic

AoiroStudio
Aug 29, 2017

Let’s take a look at the latest from Fitbit, called the Ionic (Love the name!). It’s packed with many features including personalized guidance & insights, built-in GPS, stores music, heart rate, 4+ days battery life and more. Currently, for pre-ordering, you will be able to accessorize it with bands for different aspects of your everyday routine from sport, leather and classic. I’ll be very curious to see it live and test it for every situation. From what we are seeing today from its industrial design, this may be the potential Apple Watch killer, wouldn’t you agree?

Fitbit is a brand that is located all over the World with the goal to emphasize and empower to live a healthier, more active life. They design products and experiences that fit seamlessly into your life so you can achieve your health and fitness goals, whatever they may be.

Product Gallery

 

More Links
Learn more about Fitbit Ionic at fitbit.com
Pre-Order yours at the Fitbit Store

industrial design
design
fitbit

Original Source: https://www.sitepoint.com/component-routing-angular-router/

This article is part 4 of the SitePoint Angular 2+ Tutorial on how to create a CRUD App with the Angular CLI.

Part 0— The Ultimate Angular CLI Reference Guide
Part 1— Getting our first version of the Todo application up and running
Part 2— Creating separate components to display a list of todo’s and a single todo
Part 3— Update the Todo service to communicate with a REST API
Part 4— Use Angular router to resolve data
Part 5— Add authentication to protect private content

In part one we learned how to get our Todo application up and running and deploy it to GitHub pages. This worked just fine but, unfortunately, the whole app was crammed into a single component.

In part two we examined a more modular component architecture and learned how to break this single component into a structured tree of smaller components that are easier to understand, reuse and maintain.

In part three we updated our application to communicate with a REST API backend using RxJS and Angular’s HTTP service.

In this part, we will introduce Angular router and learn how it can update our application when the browser URL changes and vice versa. We will also learn how we can update our application to resolve data from our backend API using the router.

Don’t worry! You don’t need to have followed part one, two or three of this tutorial, for four to make sense. You can simply grab a copy of our repo, checkout the code from part three, and use that as a starting point. This is explained in more detail below.

Up and Running

Make sure you have the latest version of the Angular CLI installed. If you don’t, you can install it with the following command:

npm install -g @angular/cli@latest

If you need to remove a previous version of the Angular CLI, you can:

npm uninstall -g @angular/cli angular-cli
npm cache clean
npm install -g @angular/cli@latest

After that, you’ll need a copy of the code from part three. This is available at https://github.com/sitepoint-editors/angular-todo-app. Each article in this series has a corresponding tag in the repository so you can switch back and forth between the different states of the application.

The code that we ended with in part three and that we start with in this article is tagged as part-3. The code that we end this article with is tagged as part-4.

You can think of tags like an alias to a specific commit id. You can switch between them using git checkout. You can read more on that here.

So, to get up and running (the latest version of the Angular CLI installed) we would do:

git clone git@github.com:sitepoint-editors/angular-todo-app.git
cd angular-todo-app
git checkout part-3
npm install
ng serve

Then visit http://localhost:4200/. If all is well, you should see the working Todo app.

A quick recap

Here is what our application architecture looked like at the end of part 3:

In this article we will:

learn why an application may need routing
learn what a JavaScript router is
learn what Angular router is, how it works and what it can do for you
set up Angular router and configure the routes for our application
create a resolver to fetch the todo’s from our REST API
update our application to fetch the todo’s using our new resolver

By the end of this article, you will understand:

when and why your application may need routing
the difference between routing on the server and routing in the browser
what Angular router is and what it can do for your application
how to set up Angular router
how to configure routes for your application
how to tell Angular router where to place components in the DOM
how to gracefully handle unknown URLs
what a resolver is and what it can be used for
how to use a resolver to resolve data using Angular router

So, let’s get started!

Why routing?

In its current state, our web application does not take the browser URL into account.

We access our application through one URL e.g. http://localhost:4200 and our application is not aware of any other URLs such as http://localhost:4200/todos.

Most web applications need to support different URLs to navigate users to different pages in the application. That is where a router comes in.

In traditional websites, routing is handled by a router on the server:

a user clicks a link in the browser, causing the URL to change
the browser sends an HTTP request to server
the server reads the URL from the HTTP request and generates an appropriate HTTP response
the server sends the HTTP response to the browser

In modern JavaScript web applications, routing is often handled by a JavaScript router in the browser.

What is a JavaScript router?

In essence, a JavaScript router does 2 things:

update the web application state when the browser URL changes
update the browser URL when the web application state changes

JavaScript routers make it possible for us to develop Single Page Applications (SPA’s).

A Single Page Application is a web application that provides a user experience similar to a desktop application. In a Single Page Application, all communication with a back-end occurs behind the scenes.

When a user navigates from one page to another, the page is updated dynamically without reload, even if the URL changes.

There are many different JavaScript router implementations available.

Some of them are specifically written for a certain JavaScript framework such as Angular, ember, React, Vue.js, aurelia, etc. Other implementations are built for generic purposes and are not tied to a specific framework.

What is Angular router?

Angular router is an official Angular routing library, written and maintained by the Angular Core Team.

It is a JavaScript router implementation that is designed to work with Angular and is packaged as @angular/router.

First of all, Angular router takes care of the duties of a JavaScript router:

it activates all required Angular components to compose a page when a user navigates to a certain URL
it lets users navigate from one page to another without page reload
it updates the browser’s history so the user can use the back and forward buttons when navigating back and forth between pages

In addition, Angular router allows us to:

redirect a URL to another URL
resolve data before a page is displayed
run scripts when a page is activated or deactivated
lazy load parts of our application

In this article, we will learn how to set up and configure Angular router, how to redirect a URL and how to use Angular router to resolve todo’s from our back-end API.

In the next article, we will add authentication to our application and use the router to make sure some of the pages can only be accessed when the user is signed in.

How Angular Router Works

Before we dive into the code, it is important to understand how Angular router operates and the terminology it introduces.

When a user navigates to a page, Angular router performs the following steps in order:

it reads the browser URL the user wants to navigate to
it applies a URL redirect (if one is defined)
it figures out which router state corresponds to the URL
it runs the guards that are defined in the router state
it resolves the required data for the router state
it activates the Angular components to display the page
it manages navigation and repeats the steps above when a new page is requested

To accomplish its tasks, Angular router introduces the following terms and concepts:

router service: the global Angular router service in our application
router configuration: definition of all possible router states our application can be in
router state: the state of the router at some point in time, expressed as a tree of activated route snapshots
activated route snapshot: provides access to the URL, parameters, and data for a router state node
guard: script that runs when a route is loaded, activated or deactivated
resolver: script that fetches data before the requested page is activated
router outlet: location in the DOM where Angular router can place activated components

Don’t worry if the terminology sounds overwhelming. You will get used to the terms as we tackle them gradually in this series and as you gain more experience with Angular router.

An Angular application that uses Angular router only has one router service instance; It is a singleton. Whenever and wherever you inject the Router service in your application, you will get access to the same Angular router service instance.

For a more in-depth look at Angular routing process, make sure to check out the 7-step routing process of Angular router navigation.

Enabling Routing

To enable routing in our Angular application, we need to do 3 things:

create a routing configuration that defines the possible states for our application
import the routing configuration into our application
add a router outlet to tell Angular router where to place the activated components in the DOM

So let’s start by creating a routing configuration.

Creating the routing configuration

To create our routing configuration, we need a list of the URLs we would like our application to support.

Currently, our application is very simple and only has one page that shows a list of todo’s:

/: show list of todo’s

which would show the list of todo’s as the homepage of our application.

However, when a user bookmarks / in their browser to consult their list of todo’s and we change the contents of our homepage (which we will do in part 5 of this series), their bookmark would no longer show their list of todo’s.

So let’s give our todo list its own URL and redirect our homepage to it:

/: redirect to /todos
/todos: show list of todo’s

This provides us with two benefits:

when users bookmark the todos page, their browser will bookmark /todos instead of /, which will keep working as expected, even if we change the home page contents
we can now easily change our homepage by redirecting it to any URL we like, which is convenient if you need to change your homepage contents regularly

The official Angular style guide recommends storing the routing configuration for an Angular module in a file with a filename ending in -routing.module.ts that exports a separate Angular module with a name ending in RoutingModule.

Our current module is called AppModule, so we create a file src/app/app-routing.module.ts and export our routing configuration as an Angular module called AppRoutingModule:

Continue reading %An Introduction to Component Routing with Angular Router%

Original Source: http://feedproxy.google.com/~r/1stwebdesigner/~3/2vNWC7alGpE/

Over the years, lots of different analytical tools have incorporated some form of a “heat map”. You know the ones – with the green/red/orange splotches splashed all over your beautiful website. They’re meant to show you how users are interacting with your site – at least, in theory.

But heat maps aren’t the silver bullet they’ve been made out to be. They aren’t really compatible with the modern web. That’s why FullStory developed their Page Insights feature, complete with Click Maps that simply outclass those colorful, but tired old heat maps. Let’s find out why.

The Limitations of Heat Maps

While traditional heat maps look undeniably cool, they have some real limitations when it comes to functionality:

They’re Not So Responsive
You may have noticed that visitors to your site are using all sorts of devices and screen resolutions. And that can be a problem for the good old heat map. While they can provide you with a map for a specific resolution, they can’t give you an aggregate view of all devices and resolutions. That puts your data in several silos – making it hard to get the whole picture.

They Don’t Account for Dynamic States
A single web page can be made up of several different “states”. For example, think of a page that has a modal popup window. When the popup is visible to the user – that’s a state. It’s another state entirely when that popup isn’t being shown. Heat maps don’t account for the various states a given page can be in. Items such as sliders and dynamically populated content are all treated as the same thing. That leads to a distorted view of user interaction.

They Don’t Provide Context
When a specific part of your page’s heat map is painted orange – that means it’s “hot”. But that still doesn’t provide you with any sort of in-depth knowledge as to exactly what element users are interacting with. And it doesn’t provide the context you need to turn the data into actionable information. In the end, it’s just…orange.

They Can Be Difficult to Set Up
Many heat maps require an advanced setup process that can be very frustrating – even for seasoned pros. You’re asked to configure complicated URL patterns and regular expressions in order to try and get accurate results. It can take a lot of effort and research to get right.

Click Maps Prevail Where Heat Maps Fail

FullStory actually considered adding heat maps to their service based on user demand. But as they researched all the limitations mentioned above, they decided that something new was in order. That’s how Click Maps were born. They bring a level of insight and flexibility that is simply too hot for a heat map to touch:

Click Maps are Resolution Independent and Dynamic
Because FullStory understands the structure of your website, they can translate that information across screen resolution or device type to provide you with an accurate picture. Even dynamic, data-driven interfaces are accurately interpreted, as FullStory Page Insights are focused on elements – not just screen position. That’s a smarter way to view the modern web.

Click Maps Show Every State
As you browse a web page, many elements will pop into and out of existence. FullStory lets you see that page in all its various states and provides data accordingly. In other words, you’ll only see data for that modal popup while it’s on the screen. When the popup isn’t there, its click statistics will also be hidden. You’ll only get data on the elements you see in any given state.

Click Maps are Actionable
Since Click Maps are part of FullStory (which records everything a user does on your site), that means you can use their powerful OmniSearch feature to gain incredibly deep insights. You can create segments for things like user behavior, geography, devices or make your own custom variables. With just a few clicks, you can get answers to just about any question you can think of with regards to user engagement.

Click Maps Just Work
There is no fancy setup process, no headaches and no frustration. FullStory Page Insights with Click Maps just works.

Use FullStory for Free

As we’ve discovered, FullStory’s Page Insights with Click Maps bring a whole new level of actionable data to your screen. You’re no longer limited by inaccurate heat maps. Instead, FullStory will show you exactly how users are interacting with your site – across devices and dynamic states.

Sign up for your free FullStory account today and see user engagement in a whole new way.

This article has been sponsored by Syndicate Ads.

Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/L9Wv8OR_Dk0/20-perfect-type-pairings-3132120

Finding font pairings that set each other off, don't fight the eye for attention, and harmonise without becoming homogenous and dull is tough for graphic designers. The age-old rule goes as follows: concord or contrast, but don't conflict.

But with so many professional typefaces and free fonts to choose from, how do you find two that work in harmony? Here we bring you top font pairing tips, followed by 20 examples of perfect font pairings.

Tip 1: Use font superfamilies

The easiest way to find perfect font pairings is by using different fonts within the same overarching typeface family. Find a so-called 'superfamily' and you'll have a ready-made range of weights, styles and classifications that are specifically designed to work together.

A good superfamily will include serif and a sans serif version of the same typeface: famous examples include Lucida/Lucida Sans and Meta/Meta Sans.

Best free fonts for designers
Tip 2: Pair contrasting typefaces

Contrast, as the name implies, is about finding totally different, but still complementary typefaces that are each fit for their intended application. Traditionally, this involves pairing a serif with a sans serif. 

Typefaces will generally conflict if they are too similar: two ever-so-slightly different serifs or sans serifs rarely creates nice font pairings.

As a designer, the important thing is to establish a clear hierarchy. This could be as simple as varying size and weight of the same typeface, but where the typeface varies, that's where careful font pairing is crucial. If you have a display face packed with unique personality, you'll need something more neutral to do the hard work.

Tip 3: Pair type sub-categories

Of course, 'serif' and 'sans serif' are themselves broad classifications – each split into several sub-categories. Generally speaking, Old Style serifs such as Bembo, Caslon and Garamond will combine well with Humanist sans serifs, such as Gill Sans and Lucida Grande.

Meanwhile, Transitional serifs have a stronger contrast between thick and thin strokes – examples include Bookman, Mrs. Eaves, Perpetua and Times. These pair with Geometric sans serifs such as Avant Garde, Avenir, Century Gothic, Eurostile, Futura and Univers.

Finally, Modern serifs have an often very dramatic contrast between thick and thin for a more pronounced, stylised effect, as well as a larger x-height. Included in this third sub-category are Bodoni, Didot, New Century Schoolbook and Walbaum. Again, Geometric sans serifs marry best with these.

So what does all this actually look like in practice? Here's our a reference list of tried-and-testing font pairings that are guaranteed to avoid conflict.

01. Freight Sans and Freight Text

Freight is available in a range of weights and styles

An example of a superfamily, GarageFonts' Freight is available in a large range of weights and styles, including Sans, Text, Display and Micro versions – giving you a versatile typographic toolkit.

02. Super Grotesk and Minion Pro

This match creates a luxurious finish

The ever-popular serifed Minion Pro works perfectly as a headlining font in this luxurious pairing. Coupled with the nimble sans-serif Super Grotesk, these two fonts carry a modern sense of elegance with minimal effort.

03. Kaufmann and NeutraDemi

At a dash of handwritten flair with this font pairing

The flowing, handwritten stylings of Kaufmann add a touch of personality to this odd couple. Offsetting the straight and angular sans-serifed NeutraDemi perfectly, these two might not make a likely match, but that doesn't stop them playing off one another beautifully.

04. Brandon Grotesque and Minion Pro

Minion Pro is the perfect choice for small text

The reliable Minion Pro makes another appearance, this time playing second fiddle to the bold and attention-grabbing Brandon Grotesque. It's a classic serif and sans-serif font pairing, with both typefaces remaining crisp and easy to scan.

05. Helvetica Neue and Garamond

A type match made in heaven

A famously harmonious duo, with the ubiquitous Neo-Grotesque sans serif for headlines, and the classic Old Style serif for text. Mix up weights and sizes between the two neutral families to establish hierarchy.

06. Caslon and Myriad

1700s meets late 20th century

Another classic font pairing, this time between an 18th century Old Style serif and a late-20th century Humanist sans serif. Myriad is famously used in Apple’s corporate communication, as well as in the Rolls Royce logo.

07. Fontin and Fontin Sans

These Dutch typefaces are ideal partners

Our second superfamily, Fontin was designed by Dutch foundry exljbris specifically to be used at small sizes, with a loose spacing and tall x-height. Fontin Sans is designed as an ideal partner for it.

08. Minion and Poppl-Laudatio

Two typefaces with personality that bond perfectly

An Old Style serif typeface with personality, Minion was designed in 1990 but inspired by late Renaissance era type. Although technically a sans serif, Poppl-Laudatio's subtle flared details bring out its pronounced serifs.

09. Liberation Serif and Liberation Sans

An open source superfamily pairing

Another superfamily, which also includes Sans Narrow and Mono variations, Liberation was intended as an open-source substitute for many commonly used Windows fonts, such as Arial, Times New Roman and Courier New.

10. Trade Gothic Bold and Sabon

These readable typefaces combine well

This pairing is particularly effective when Trade Gothic is used in its Bold weight for headlines, to set off Jan Tschichold's classic Old Style serif face for text. Both typefaces are highly readable, with a tall x-height, and combine well.

11. Scala and Scala Sans

A hugely versatile pairing

FontFont’s superfamily began with the serif version in 1990, followed in ’92 by its sans serif companion. With small caps, various ligatures and old-style figures, it’s hugely versatile and widely used in publishing.

12. Rockwell Bold and Bembo

Bold and attention-grabbing meets calmly neutral

One of the classic slab serifs, Rockwell was designed in the 1930s and has a huge amount of personality and attention-grabbing potential when used bold. The much more conservative serif Bembo is neutral but versatile.

13. Myriad Black and Minion

A great combination for clear hierarchy

Myriad and Minion have already cropped up in different font pairings earlier in the list, but this combination of the shouty ultra-bold Black version of the former and the text weight of the latter achieves clear hierarchy.

14. Souvenir and Futura Bold

Two strong type personalities that work well together

Mixing two strong typographic personalities rarely works, as they end up fighting. Souvenir is softer and more playful than many of its Old Style serif counterparts, while Futura Bold is quirky without being too dominant.

15. Dax Bold and Caslon

Caslon’s second entry on this list

One of the most versatile Old Style serifs, Caslon also appeared earlier on this list. Its neutrality lets the informal, modern Dax Bold deliver strong personality for a headline without competing for attention.

16. Aviano and Aviano Sans

Two tilting typefaces working in harmony

Only available in all-caps varieties, Aviano has sharp, edgy serifs that give it a distinctive personality – while its sans serif version is smoother. They combine well to create hierarchy between two titling faces.

17. Antique Olive Bold and Chaparral

A quite distinctive font pairing

Initially designed as an alternative to Helvetica and Univers, Antique Olive has a very tall x-height with short ascenders and descenders that make it highly distinctive in display form. Chaparral has a modern feeling but is a much more neutral slab serif.

18. TheSerif and TheSans

These typefaces were made to work together

The rather straightforward naming strategy within LucasFonts’ Thesis typeface superfamily makes the foundry's intentions pretty clear: these are totally complementary, and each comes with its own sub-varieties.

19. Renault Light and Apex-New

Contemporary sans serif meets authoritative serif

An ideal combination for formal corporate use: both Renault and Apex-New have a very similar ratio of x-height to body height for an effortless partnership between contemporary sans serif and authoritative serif.

20. Calluna and Calluna Sans

Calluna was born from experimentation

Another exljbris creation, Calluna was born out of an experiment with adding slab serifs to Museo, giving designer Jos Buivenga the idea of 'serifs with direction'. The result is a highly distinctive text face that later spawned a sans serif companion.

You might like these other typography articles:

20 fonts every graphic designer should ownHow to create your own font5 fonts created by famous designers and why they work

Original Source: https://www.smashingmagazine.com/2017/08/ux-mba-designer-business/

 

 

If great design can imbue customers with trust, why are designers so removed from product management and the larger business strategy? As a VP of UX with an MBA, I strive to bring both worlds together to create a new model in which user experience and design align with overall business strategy and company vision to drive increased revenue and customer engagement.

As the Internet became commercially viable, “first to market” generally prevailed as a dominant corporate strategy. However, as technology has become more open and reusable, product differentiation is now a proven strategic blueprint. This tectonic shift has been a boon for the design discipline. Consequently, design has gotten the proverbial “seat at the table” and is now expected to be a driving, strategic function.

The post UX Meets MBA: What Happens When A Designer Goes To Business School appeared first on Smashing Magazine.