Original Source: https://www.sitepoint.com/productivity-tips-for-webstorm-and-angular-part-1/

This article was sponsored by JetBrains. Thank you for supporting the partners who make SitePoint possible.

In this 2-part series, Google Developer Experts Jurgen Van de Moere and Todd Motto share their favorite productivity tips for developing Angular applications using WebStorm.

In this first part, Jurgen shares his personal top 5 WebStorm features that allow him to increase his productivity on a daily basis:

Use Angular CLI from within WebStorm
Navigate like a pro
Take advantage of Angular Language Service
Auto format your code
Optimize your imports

Each tip can tremendously increase your development productivity, so let’s dig into them a little deeper one by one.

Tip 1: Use Angular CLI from Within WebStorm

Angular CLI is a Command Line Interface (CLI), written and maintained by the Angular team, to help automate your development workflow. You can use it to quickly create new Angular projects and add new features such as components, services and directives to existing Angular projects.

WebStorm’s integration with Angular CLI provides you with all its power right from within WebStorm, without using the terminal.

To create a new Angular Project, choose File | New | Project and select Angular CLI.

Enter a project location and hit the Create button. WebStorm uses Angular CLI to create a new Angular project and install dependencies.

When your new Angular application is in place, you can easily add new Angular features. Right click on src/app and choose New | Angular CLI to pick the type of feature you wish to add.

Once you’ve selected a feature, you can specify the name and optional parameters, just as you would with Angular CLI on the command line:

To learn more about Angular CLI options and parameters, make sure to check out The Ultimate Angular CLI Reference.

What’s really awesome is that WebStorm automatically adds the component to the right Angular module for you, in this case AppModule.

If your application has multiple Angular modules, right click on the module you wish to add the feature to and choose New | Angular CLI. WebStorm will make sure the new files are created in the right location and that the new feature is added to the correct Angular module.

How sweet is that!

Tip 2: Navigate Like a Pro

Use cmd-click or cmd-B to easily jump to any definition within your project.

If you are a keyboard user, just put your cursor on a term and hit cmd-B. If you are a mouse user, hold down the cmd button and all terms you hover will turn into links to their definition.

WebStorm automatically recognizes Angular components and directives in your HTML, links to stylesheets, links to templates, classes, interfaces and much more.

No need to open file(s) manually, just jump to any definition you need:

When looking for a file that you don’t have an immediate reference to, hit shift twice to open the Search everywhere dialog. You don’t have to type the entire search string. If you want to open AppComponent, just type the first letter of each part — i.e. ac — and WebStorm will immediately narrow down the result list for you, so you can quickly pick the suggestion you wish to open:

Another super useful navigation shortcut is cmd-E, which presents you with a list of recently edited files so you can easily navigate back and forth between them.

Knowing how to quickly navigate to the code you need will save you a tremendous amount of time every single day.

Tip 3: Take Advantage of Angular Language Service

Angular Language Service is a service, designed by the Angular Team, to provide IDEs with error checking and type completion within Angular templates.

WebStorm integrates with Angular Language Service to better understand your code. To enable Angular Language Service, first make sure it is installed:

npm install @angular/language-service –save-dev

If you use Angular CLI to generate an Angular application, Angular Language Service is automatically installed.

Next, go to Preferences | Languages & Frameworks | TypeScript, make sure Use TypeScript Service is checked and click Configure…:

The Service Options modal will pop up. Enable Use Angular service and apply the changes:

By default, WebStorm already provides great assistance for writing Angular code.

When editing a script, WebStorm automatically imports the required JavaScript modules so you don’t have to import them manually.

If you open up the TypeScript panel, WebStorm provides you with immediate feedback on the validity of your code, so you can quickly resolve issues before having to compile your project.

Watch how the OnInit interface is automatically imported and how the live TypeScript feedback immediately tells you whether or not your TypeScript code is valid:

When you edit a template, WebStorm provides you with smart code completion that recognizes components, directives and even input and output properties:

With Angular Language Service enabled, WebStorm is able to improve code completion in template expressions:

… and report template errors more precisely right inside your editor:

Catching errors without having to compile your project saves you incredible amounts of time.

Tip 4: Auto-format Your Code

Don’t worry about formatting your code manually. WebStorm has you covered.

Whether your are in a template, a script, a stylesheet or even a JSON file, just hit cmd-option-L and WebStorm will automatically format all code for you:

Continue reading %Top 12 Productivity Tips for WebStorm and Angular – Part 1%

Original Source: http://feedproxy.google.com/~r/tympanus/~3/YIJfw2is-kk/

Our Sponsor
Online Master’s in Information Design and Strategy

This online, part-time program at Northwestern University is taught by industry leaders and top professors.

Check it out

Metaballs

A fantastic write up on how those organic looking squishy gooey blobs work with SVG path-only manipulations. By Varun Vachhar.

Read it

Design Beyond a Screen: A Primer for VR, AR and the Multiverse

A great introduction to the different types of realms we can potentially work with. By Graeme Fulton.

Read it

Introducing PayPal’s open-source cross-domain JavaScript suite

Paypal has open sourced a set of tools to make the integration on third-party sites easier and more reliable.

Read it

Schnack.js

Schnack.js is an ad-free, open source Disqus clone that comes with a very minimal, hackable code base.

Check it out

Design for Developers: Specific Steps to Improve Your Website Design

Some clear tips on how to become better at critiquing and improving ones own site as a non-designer.

Read it

Naming Things In CSS Grid Layout

Rachel Andrew takes an in-depth look at the various ways to name lines and areas in CSS Grid Layout.

Read it

sketch-to-react-native

Automatically create React Native components out of Sketch designs.

Check it out

Key Reinstallation Attacks

Mathy Vanhoef has discovered an extremely crucial security weakness in all modern WPA2 protected Wi-Fi networks.

Read it

Only CSS: Creamy <3

A fun CSS-only demo by Yusuke Nakaya.

Check it out

How open source licenses work and how to add them to your projects

Radu Raicea gives an overview of popular open source licenses and teaches how to apply them to your GitHub projects.

Read it

While Apple is taking away buttons, we found a way to add one

Savannah Reising introduces the brilliant solution for Luna Display that adds another “button” to the iPad using the camera.

Read it

The Art of Comments

Gread read by Sara Drasner on the necessity of commenting code.

Read it

Image Trace Loader

Based on Mikael Ainalem’s interesting idea, this library loads images and exports traced outlines as image/svg+xml URL-encoded data. By Emil Tholin.

Check it out

Sequence Creator with Web Audio API

An Excel-like sequence creator made with canvas and the Web Audio API. By Jon Kantner.

Check it out

How to structure components in React

An article by Bartek Witczak on how to properly structure React component.

Read it

Geometrical Birds Slideshow

A slideshow with morphing geometrical birds by Mikael Ainalem.

Check it out

Web Typography: Numerals

An excerpt from Chapter 2 of Richard Rutter’s new book, “Web Typography”.

Read it

Experiments

A repo for collecting Audio/VR/AR/GL experiments. By Jordan Santell.

Check it out

Fontplop

An OSX/macOS application that takes ttf and otf files and outputs a webfont bundle with woff2, woff, tff, svg, and eot.

Check it out

Hillclimber

Hillclimber is a curated machine learning mashup resource.

Check it out

Monopoly board

John Coppola made this Monopoly board with CSS grid.

Check it out

Library Symbol Replacer

A Sketch plugin for replacing symbols in an existing document with library symbols

Check it out

Collective #358 was written by Pedro Botelho and published on Codrops.

Original Source: https://www.sitepoint.com/ember-js-perfect-framework-web-applications/

Ember.js is an opinionated frontend JavaScript framework that has been getting a lot of interest lately. This article will introduce some key concepts of the framework while building a simple application with it, in order to show a basic example of what it is capable of producing.

Our example application is going to be a Dice Roller, including the ability to roll some dice and view a history of all dice rolls that have been performed to date. A fully working version of this application is available from Github

The Ember.js framework pulls together a lot of modern JavaScript concepts and technologies into one single bundle, including but not limited to:

The use of the Babel transpiler tool, to support ES2016 throughout.
Testing support at the Unit, Integration and Acceptance levels as standard, powered by Testem and QTest.
Asset building using Broccoli.js.
Support for live reloading, for shorter development cycle times.
Templating using the Handlebars markup syntax.
URL Routing first development to ensure that deep linking is fully supported throughout.
Full data layer built around JSON API, but pluggable for whatever API access you need.

In order to work with Ember.js, it is assumed that you have an up-to-date installation of Node.js and npm. If not then these can be downloaded and installed from the Node.js website.

It should also be mentioned that Ember is purely a frontend framework. It has a number of ways of interacting with the backend of your choice, but this backend is not in any way handled by Ember itself.

Introducing ember-cli

A lot of the power of Ember.js comes from its command line interface (CLI). This tool – known as ember-cli – powers much of the development lifecycle of an Ember.js application, starting from creating the application, through adding functionality into it all the way to running the test suites and starting the actual project in development mode.

Almost everything that you do whilst developing an Ember.js application will involve this tool at some level, so it is important to understand how best to use it. We will be making use of it throughout this article.

The first thing we need to do is ensure that the Ember.js CLI is correctly installed and up-to-date. This is done by installing from npm, as follows:

$ npm install -g ember-cli

and we can check it was successfully installed by running the following command:

$ ember –version
ember-cli: 2.15.0-beta.1
node: 8.2.1
os: darwin x64

Creating Your First Ember.js App

Once ember-cli is installed, you are ready to start creating your application. This is the first place we will be making use of the Ember.js CLI tool – it creates the entire application structure, setting everything up ready to run.

$ ember new dice-roller
installing app
create .editorconfig
create .ember-cli
create .eslintrc.js
create .travis.yml
create .watchmanconfig
create README.md
create app/app.js
create app/components/.gitkeep
create app/controllers/.gitkeep
create app/helpers/.gitkeep
create app/index.html
create app/models/.gitkeep
create app/resolver.js
create app/router.js
create app/routes/.gitkeep
create app/styles/app.css
create app/templates/application.hbs
create app/templates/components/.gitkeep
create config/environment.js
create config/targets.js
create ember-cli-build.js
create .gitignore
create package.json
create public/crossdomain.xml
create public/robots.txt
create testem.js
create tests/.eslintrc.js
create tests/helpers/destroy-app.js
create tests/helpers/module-for-acceptance.js
create tests/helpers/resolver.js
create tests/helpers/start-app.js
create tests/index.html
create tests/integration/.gitkeep
create tests/test-helper.js
create tests/unit/.gitkeep
create vendor/.gitkeep
NPM: Installed dependencies
Successfully initialized git.

$

This has caused an entire application to be created which is ready to run. It has even set up Git as source control to track your work.

Note: If you wish, you can disable the Git integration and you can prefer Yarn over npm. The help for the tool describes this and much more.

Now, let’s see what it looks like. Starting the Ember application for development purposes is – once again – also done using ember-cli:

$ cd dice-roller
$ ember serve
Livereload server on http://localhost:49153
‘instrument’ is imported from external module ’ember-data/-debug’ but never used
Warning: ignoring input sourcemap for vendor/ember/ember.debug.js because ENOENT: no such file or directory, open ‘/Users/coxg/source/me/writing/repos/dice-roller/tmp/source_map_concat-input_base_path-2fXNPqjl.tmp/vendor/ember/ember.debug.map’
Warning: ignoring input sourcemap for vendor/ember/ember-testing.js because ENOENT: no such file or directory, open ‘/Users/coxg/source/me/writing/repos/dice-roller/tmp/source_map_concat-input_base_path-Xwpjztar.tmp/vendor/ember/ember-testing.map’

Build successful (5835ms) – Serving on http://localhost:4200/

Slowest Nodes (totalTime => 5% ) | Total (avg)
———————————————-+———————
Babel (16) | 4625ms (289 ms)
Rollup (1) | 445ms

We are now ready to go. The application is running on http://localhost:4200, and looks like this:

It is also running a LiveReload service which automatically watches for changes to the filesystem. This means that you can have an incredibly fast turnaround time when tweaking your site design.

Let’s try it?

The initial page already tells us what to do, so let’s go and change the main page and see what happens. We’re going to change the app/templates/application.hbs file to look like the following.

This is my new application.

{{outlet}}

Note: The {{outlet}} tag is part of how Routing works in Ember. We will cover that later on.

The first thing to notice is the output from ember-cli, which should look as follows:

file changed templates/application.hbs

Build successful (67ms) – Serving on http://localhost:4200/

Slowest Nodes (totalTime => 5% ) | Total (avg)
———————————————-+———————
SourceMapConcat: Concat: App (1) | 9ms
SourceMapConcat: Concat: Vendor /asset… (1) | 8ms
SimpleConcatConcat: Concat: Vendor Sty… (1) | 4ms
Funnel (7) | 4ms (0 ms)

This tells us that it has spotted that we changed the template and rebuilt and restarted everything. We’ve had zero involvement in that part of it.

Now let’s look at the browser. If you’ve got LiveReload installed and running you will not even have needed to refresh the browser for this to be picked up, otherwise, you will need to reload the current page.

Not very exciting, but this is with almost no effort on our part that we’ve achieved this.

In addition, we get a fully set up test suite ready to run. This is – unsurprisingly – run using the Ember tool as well, as follows:

$ ember test
⠸ Building’instrument’ is imported from external module ’ember-data/-debug’ but never used
⠴ BuildingWarning: ignoring input sourcemap for vendor/ember/ember.debug.js because ENOENT: no such file or directory, open ‘/Users/coxg/source/me/writing/repos/dice-roller/tmp/source_map_concat-input_base_path-S8aQFGaz.tmp/vendor/ember/ember.debug.map’
⠇ BuildingWarning: ignoring input sourcemap for vendor/ember/ember-testing.js because ENOENT: no such file or directory, open ‘/Users/coxg/source/me/writing/repos/dice-roller/tmp/source_map_concat-input_base_path-wO8OLEE2.tmp/vendor/ember/ember-testing.map’
cleaning up…
Built project successfully. Stored in “/Users/coxg/source/me/writing/repos/dice-roller/tmp/class-tests_dist-PUnMT5zL.tmp”.
ok 1 PhantomJS 2.1 – ESLint | app: app.js
ok 2 PhantomJS 2.1 – ESLint | app: resolver.js
ok 3 PhantomJS 2.1 – ESLint | app: router.js
ok 4 PhantomJS 2.1 – ESLint | tests: helpers/destroy-app.js
ok 5 PhantomJS 2.1 – ESLint | tests: helpers/module-for-acceptance.js
ok 6 PhantomJS 2.1 – ESLint | tests: helpers/resolver.js
ok 7 PhantomJS 2.1 – ESLint | tests: helpers/start-app.js
ok 8 PhantomJS 2.1 – ESLint | tests: test-helper.js

1..8
# tests 8
# pass 8
# skip 0
# fail 0

# ok

Note that the output talks about PhantomJS. This is because there is full support for Integration tests that run in a browser, and by default, these run headless in the PhantomJS browser. There is full support for running them in other browsers if you wish, and when setting up continuous integration (CI) it is worth doing this to ensure that your application works correctly in all supported browsers.

How an Ember.js app is structured

Before we get to actually writing our application, let’s explore how it is structured on the filesystem. The ember new command above will have created a whole directory structure on your computer, with lots of different parts. Understanding all of these is important to efficiently work with the tool and create amazing projects.

Continue reading %Ember.js: The Perfect Framework for Web Applications%

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

The launch of iOS 11 has resulted in a great selection of resources being designed and released.

These include iPhone X grids, full iOS 11 app designs, beautiful device mockups, app icons, and complete UI kits.

Many of these have been executed to an incredibly high standard and are available for various applications, including Sketch, Photoshop, Adobe XD, and Figma. As well as this, most resources are free for personal and commercial use, meaning you can download and play with as many of them as you like.

They are a perfect aid when building your next app, and also a valuable resource to learn the specifications and features of iOS 11 and the iPhone X.

In this collection we bring together ten of the most beautiful and free iOS 11 resources for you.

Dark & Light iPhone X Minimal

These minimal iPhone X mockups for Adobe XD are perfect for showcasing your iOS 11 app designs. They come in both light and dark variants.

iOS 11 GUI

This iOS 11 GUI Template is incredibly useful as a resource and reference when designing an app for iPhone X and/or iOS 11. It has almost every element you could ever need and also comes in handy for copying across visual effects and spacing.

8 iOS 11 Icons Sketch Resource

These 8 icons are a great starting point if you’re designing or redesigning an app icon for iOS 11. The style is much-refined, as are the icon graphics.

Food Dark iOS 11

This dark food app resource for iPhone is a stunning example of what can be achieved within iOS 11 guidelines. It has effectively carried through many elements you’ll find in default iOS apps like the app store.

iOS 11 Grid Template Sketch Resource

This grid template is incredibly handy when starting out on a new iPhone app design project. The grids are clear and structured and save a great deal of time and energy when laying out a new user interface.

iPhone X Wireframe with iOS 11 Guides

These blue iPhone X wireframe templates are beautifully put together and serve as the perfect base for building mid- to high- fidelity wireframes upon. They would also be great for printing and sketching low fidelity wireframes on.

If you’re looking for more free wireframe templates, take a look at this collection.

Verb App for iOS 11 Sketch Resource

Another great example of an iOS 11 app design is this Verb app kit for Sketch. It’s beautifully presented and incorporates a wide variety of elements and styles from Apple’s user interface guidelines.

iPhone X Clay

These clay iPhone X mockups offer a slightly different style to standard mockups. They strip away the intricacies of the actual iPhone design and work perfectly when combined with minimal user interface designs.

iOS 11 App Store Sketch Resource

This recreation of the redesigned iOS 11 app store is a great resource when examining the new direction of iOS. It includes many of the new elements and styles including buttons, icons, rounded images, and larger input fields.

iPhone X 4K Mockups

This realistic iPhone X mockup, made in Cinema 4D, is extremely close to being mistaken for a photograph. The shadows and highlights are perfectly crafted and present a resource that would look exceptional on any landing page design.

You might also like:

10 Free Mockup Templates for Featuring Mobile Apps
10 Incredibly Detailed Free Mobile UI Kits For Sketch

Original Source: https://www.sitepoint.com/symfony-flex-paving-path-faster-better-symfony/

Symfony Flex is a modern replacement for the Symfony Installer, and not the name of the next Symfony version. As the intro text says:

Internally, Symfony Flex is a Composer plugin that modifies the behavior of the require and update commands. When installing or updating dependencies in a Flex-enabled application, Symfony can perform tasks before and after the execution of Composer tasks.

The new Symfony will be called just Symfony 4, and while this tutorial will deal only with the Flex tool, it will mention some Symfony 4 upgrades as well.

Still Under Development

Symfony Flex can be considered a Composer wrapper, in that it provides your Symfony project with additional options during installation and configuration. It was developed with simplicity in mind, and obviously heavily influenced by the user-friendliness of Laravel. Remember, Laravel got to its current level of popularity due to its ease of use and the low entry barrier it provides newcomers with, and Symfony wanted to emulate this.

It should be noted that both Flex and Symfony 4 are still under development, slated for release somewhere at the end of November this year (2017). As such, some of the features mentioned in this post may have changed by the time you read it, but we’ll do our best to keep it up to date.

Most notably, the use of a makefile and the make tool to build a project if Symfony/Console is unavailable is still up in the air, as it seems to not be working properly on some operating systems. Fabien recently held a survey around this, asking for the community’s suggestions to a replacement, and overwhelmingly, the community voted in favor of just making Symfony/Console required.

What’s Different?

Most notably, Flex respects the coming Symfony 4 updates which boil down to the following major changes:

PHP 7+ is required
all folders are optional. If your project isn’t using one, it doesn’t have to be there. This makes the directory tree much simpler and more readable. Additionally, often useless files like .htaccess, LICENSE, and README have been removed as well – a project which needs those can easily add them.
there is no more web folder. Instead, there is the public folder, like in all other major frameworks. This consolidates user experience across ecosystems.
temporary files go under /var in the root of the project folder, with the /var/cache subfolder reserved for long term cache, like merged class files for deploying apps as read-only artifacts
source code goes under /src. No /app.
configuration goes into /config.
templates go into /templates.
Flex will have its own Symfony-verified list of packages that are referenced by one and one alias alone. So executing composer require cli will actually trigger Flex, which will look in its list of packages, find the one tagged as cli (in this case, Symfony Console), and install it. These “official” packages are called recipes, and can be found here. To accept user-submitted recipes, a flag exists in Flex’s configuration which needs to be set to true: composer config extra.symfony.allow-contrib true. Those recipes can be found here. By officially endorsing some packages, Symfony is in many ways becoming as opinionated as Laravel. While this is bad in some ways, it’s very good in many more ways: a consolidated, opinionated way to build Symfony apps used by most people so that everyone is on the same page.
bundle fragments no longer need to be custom-activated and added into a ton of files. Flex automates this, as well as their removal.
instead of parameters in config files, Symfony 4 will be using environment variables like Laravel

Bootstrapping

As usual, we’ll assume you’re already running a healthy VM environment like Homestead Improved so you can follow along.

Okay, let’s get our hands dirty with an example app. All Symfony apps can now be started from the bare bones super-minimal Symfony Skeleton app:

composer create-project symfony/skeleton flexy

Notice the created directory structure.

In /public, we no longer have app.php and app_dev.php, only the index.php file. The type of the environment (test / dev / prod) is now dictated with environment variables, and reads the configuration from the /config folder.

Notice how the end of the installation process mentions that make cache-warmup was called, and that you can run make serve. This is where the new Symfony uses the “controversial” Makefile approach mentioned above. This might change.

Out of the box, opening this skeleton in the browser will throw an error because no routes have been defined yet. Let’s fix this.

index:
path: /
defaults: { _controller: ‘AppControllerDefaultController::index’ }

config/routes.yaml

We’ll need to create this controller and its index action:

<?php

namespace AppController;
use SymfonyComponentHttpFoundationResponse;

class DefaultController
{
public function index()
{
return new Response(‘Hello’);
}
}

This will produce a simple Hello screen, like so:

Execution Permissions

If you try to install a binary like the Symfony/Console with composer req cli, you might run into the following problem:

~ bin/console
-bash: bin/console: Permission denied

This is a known hiccup when using virtual machines, and can be easily fixed by either:

running the console with php bin/console instead of running it directly, or
adding the “execute” permission to the file on the host machine (not from within the virtual machine), by executing: chmod +x bin/console. This will allow the direct execution of bin/console from within the VM then.

Continue reading %Symfony Flex: Paving the Path to a Faster, Better Symfony%