    
|
|
|
|
|
|
|
The June edition of what’s new for web designers and developers includes new web apps, JavaScript resources, Photoshop scripts, web development tools, color palette tools, image apps, video resources, coding resources, and some really great new fonts.
Many of the resources below are free or very low cost, and are sure to be useful to a lot of designers and developers out there.
As always, if we’ve missed something you think should have been included, please let us know in the comments. And if you have an app or other resource you’d like to see included next month, tweet it to @cameron_chapman for consideration.
Premailer is an online pre-flight app for HTML email creation. Just paste in your URL or source, add a query string to append to links, and add options (like removing unused IDs, comments, or classes), and submit.
Pixa is a $30 Mac app that makes it easy to organize your images into collections. It helps you quickly find and share your pictures, and works with a ton of different image formats, including psd, ai, svg, raw, and many others.
Codifferous helps you review code faster and more effectively. It tracks how much you’ve reviewed within the source code, and even lets you mark whether each line is accepted or rejected. Public projects are free, while private projects will eventually require a small fee.
Ladda is a UI concept that merges loading indicators into your submit buttons, so that your users aren’t left wondering whether clicking submit actually did anything.
Stocksy is a stock photo service that offers high-quality, royalty-free photos that are unlike most stock photos and exclusive to Stocksy. Photos start at just $10.
Tourist.js makes it simple to create guided tours of your app. It includes hooks for things like opening windows or menus, or for waiting for a user to complete certain tasks.
TODC Bootstrap is a Google-style theme for Twitter Bootstrap that’s packed with features like a 12-column responsive grid, tons of components, JavaScript plugins, form controls, and typography.
Videry is a curated collection of videos for web designers. There are videos on a variety of topics featured, including CSS, innovation, psychology in design, typography, and much more.
This set of UI Icons comes with 704 minimalist, monochrome icons in the premium version (there’s a free version with a more limited set, too). They’re all delivered in PSD, AI, EPS, and SVG format, ready to use.
Pure is a set of responsive CSS modules that you can use in all of your website and app projects. It includes modules for grids, forms, buttons, tables, menus, and more.
Bounce lets you integrate Dribbble into your design programs, so you can stay up to date on what’s happening without ever leaving Photoshop, Illustrator, InDesign, or Fireworks.
This collection of 430+ Free Storyboard Illustrations is free for you to use for your personal projects (it’s not made to be used in final production projects). It includes a vector file, as well as a PNG file.
SketchMine is a collection of sketch files from the design community. Sketches are categorized by OS, device, icons, mockups, and more.
Guifff is a collection of animated GIFs from Dribbble. There are tons of awesome shots included here, all with permalinks to their respective Dribbble pages.
Red Pen makes it super fast and easy to get feedback from your clients or team members. Just drag your design onto the upload area, share the short URL you’re provided with, and get live, annotated feedback. And there’s no logging in, project management, or other useless features.
Designers Complaining is an awesome Tumblr blog that catalogs complaints from designers from across the web. Most recently has been a huge number of complains about iOS 7.
Roon is a super simple blogging platform that’s cross-platform compatible. It removes 99% of the distractions that come along with blogging, leaving you free to focus on your content.
React is a JavaScript library for building great UIs. It uses a declarative paradigm for easier reasoning, computes the minimal number of changes necessary to keep your DOM up to date, and will work with the libraries and frameworks you’re already using.
Need a website for documenting your open source project? Flatdoc is here to help. It lets you create a website fast, using Markdown.
Breakouts is a selection of JavaScript game engines demonstrating the classic game Breakout, to help you choose which engine is best for your project.
Explore. Create. Repeat. is an online weekly magazine for the creative community, to inspire and offer insight. You can subscribe by email or read it online.
Popular UIs is a collection of popular website user interface PSDs you can download. These are, of course, recreated for educational purposes only.
Unsplash is a new Tumblr blog offering hi-resolutions photos for your website or other creative projects. They add ten new copyright-free photos every 10 days.
Projecteo is a tiny Instagram projector that works with photo wheels, each holding nine of your Instagram photos. The project is less than $26, and the wheels are each under $9.
Colourcode is a color scheme design tool that lets you select a color by hovering over the page, and then choose a standard color scheme pattern using the slide-out menu.
Six UX is a collection of six second UX videos for inspiration. You can browse depending on what type of UI effect you’re looking for, including animation, transition, CSS, iOS, navigation, and more.
Prepros is an app for compiling a variety of languages, including Less, Sass, Scss, Coffeescript, Haml, Markdown, and more. It’s available as a Chrome Extension or a Windows application.
The TemplateGen Beta script is a Photoshop script for starting your projects with better templates. You can easily create a new document that includes things like grids, OS X Icon squares, iOS Icons roundrects, and even create your own templates.
CSS Modal lets you create modal windows entirely with pure CSS, with added JavaScript for extra flare. It’s optimized for mobile use, and can be used as a Sass plugin.
Wri.pe is a smart web notepad that you can sign into with Facebook. It includes shortcut keys and Markdown support, is available on any device, backs up to the cloud, and includes calendar-based organization.
Klinic Slab is a slab serif font in four weights (plus italics). It’s a contemporary workhorse that has both personality and functionality.
Albert Sans & Serif is a type family that includes both a slab serif and a sans serif font. It’s modern and a little bit funky, but still highly legible.
Engine is a free handwritten font with a playful personality. It comes in regular and italic.
Chomp is a playful, fun typeface with a brush script quality. It comes with uppercase characters, numbers, and punctuation.
Gin is a vintage display typeface that comes in eight styles and weights. It’s reminiscent of old serif fonts and classic bottles of whiskey and gin.
Lunch Box is a unique, handdrawn typeface with infinite customizable options. It also comes with a custom set of small caps, each with four style variations, and stylistic alternatives.
Percival Script is currently a teaser for a script that will be released at a later date. It’s downloadable as an EPS file right now, but the full release version will include a sans version, capitals, numerals, and more.
Operator is a slim display typeface that’s great as a headline font. It includes 175 glyphs and comes as both a desktop and web font.
Font Awesome 3.2.0 has a number of new features, including 58 new icons, pixel perfection at 14px (Bootstrap’s default size), and more.
Yuma is an experimental typeface inspired by Navajo textiles with strong geometric patterns.
Know of a new app or resource that should have been included but wasn’t? Let us know in the comments!
| Beautiful Samantha Script Font – only $17! |  |
|
|
From different angles, two of our feature stories explore the role of humans in an automated world.
While we await Immanuel Kant’s perpetual peace, there will be wars; and if the president of the United States must sometimes defend the bad against the worse, perhaps it’s as well that he should make war with unmanned aerial vehicles, or drones.
]]>|
|
|
|
|
|
The aim of this tutorial is to show off Python’s data structures and the best way to use them. Depending on what you need from a data structure, whether it’s fast lookup, immutability, indexing, etc, you can choose the best data structure for the job and most of the time, you will be combining data structures together to obtain a logical and easy to understand data model.
Python data structures are very intuitive from a syntax point of view and they offer a large choice of operations. This tutorial tries to put together the most common and useful information about each data structure and offer a guide on when it is best to use one structure or another. You can choose different kinds of data structures depending on what the data involves, if it needs to be modified, or if it’s fixed data, and even what access type you would like, such as at the beginning/end/random etc.
A List represents the most versatile type of data structure in Python. It can contain items of different types and it has no rule against unicity. List indices start from zero, the elements can be sliced, concatenated, and so on. Lists also have a lot of similarities with strings, supporting the same kind of operations but unlike strings, lists are mutable.
A list can be built using the keyword list or using square brackets: [], both of which accept comma separated values. Here’s an example:
>>> l = ['a', 'b', 123]
>>> l
['a', 'b', 123]
>>> l[0]
'a'
>>> l[10]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
As seen above, in order to access the data within your list, you must know what index position the element is at, otherwise you get an “index out of range” error.
All slicing operations return a shallow copy of the list. The slicing indexes are optional and they work in the same way as slicing indexes for strings.
Here’s an example of how to slice a list:
>>> l = ['a', 'b', 123]
>>> l[:]
['a', 'b', 123]
>>> new_l = l[1:]
>>> new_l
['b', 123]
>>> l
['a', 'b', 123]
Let’s take a look at some other common list operations.
>>> l = ['a', 'b', 123]
>>> l.append(234) #inserts an element at the end of the list
>>> l
['a', 'b', 123, 234]
>>> l.insert(2, 'c') #inserts an element into the third position
>>> l
['a', 'b', 'c', 123, 234]
>>> l.insert(-1, 111) #inserts an element into the second from last position of the list (negative indices start from the end of the list)
>>> l
['a', 'b', 'c', 123, 111, 234]
>>> l.remove(111) #removes an element based on value
>>> l
['a', 'b', 'c', 123, 234]
>>> l.remove('does not exist in the list')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
Lists can also be used as stacks or queues because of how easy it is to add and remove elements from the beginning or end of the list.
>>> last_element = l.pop() #returns the last element, modifying the list
>>> last_element
234
>>> l
['a', 'b', 'c', 123]
>>> third_element = l.pop(2) #returns the third element, modifying the list
>>> third_element
'c'
>>> l
['a', 'b', 123]
>>> l.index('a')
0
>>> l.index('does not exist in the list')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'does not exist in the list' is not in list
>>> l.count('a') #returns the number of occurrences of an element
1
>>> l.extend ([1, 2]) # concatenates a list on to the existing list
>>> l
['a', 'b', 123, 1, 2]
>>> l.sort()
>>> l
[1, 2, 123, 'a', 'b']
>>> l.reverse()
>>> l
['b', 'a', 123, 2, 1]
As you can see, it’s very easy to extend, sort, and reverse lists using the above methods.
A list comprehension means, constructing a list in a way that is very natural from a mathematical point of view. The code for doing this is brief and very easy to read. A simple example of when you would use list comprehensions is when you want to construct a new list based on the elements from another list. Let’s have a look at how you can multiply all of the elements of a numeric list by two, in a simple one line construct:
>>> l = [1, 2, 3]
>>> new_l = [x*2 for x in l]
>>> new_l
[2, 4, 6]
In the example above, the comprehension is represented by the multiplication expression that will be applied to every x element in the original, l list.
As shown in the examples above, lists are best used in the following situations:
A set is an unordered collection with no duplicate values. A set can be created by using the keyword set or by using curly braces {}. However, to create an empty set you can only use the set construct, curly braces alone will create an empty dictionary.
Use the
setkeyword to create an empty set, curly brackets{}will create an empty dictionary.
The set construct accepts one argument, a list.
>>> l = [1, 2, 3]
>>> s = set(l)
>>> s
set([1, 2, 3])
The {} construct is straight forward as well:
>>> s = {1, 2, 3}
>>> s
Sets are used to eliminate duplicate values from within a list:
>>> l = [1, 2, 3, 3]
>>> s = set(l)
>>> s
set([1, 2, 3])
The way a set detects if a clash between non-unique elements has occurred is by indexing the data in memory, creating a hash for each element. This means that all elements in a set must be hashable.
Here is an example:
>>> set ([1, [1,2]])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
Note that a hashable object doesn’t necessarily mean that an object has the __hash__ method available to it. It is important that the hash of the object doesn’t change during its lifetime, which is obviously not the case with lists, sets, or dictionaries (dictionaries will be discussed later in this tutorial).
The set structure also supports mathematical operations like:
Here are a few examples:
>>> set1 = set([1, 2, 3])
>>> set2 = set([3, 4, 5])
>>> set1 | set2 #union
set([1, 2, 3, 4, 5])
>>> set1 & set2 #intersection
set([3])
>>> set1 - set2 #difference
set([1, 2])
>>> set1 ^ set2 #symmetric difference (elements that are in the first set and the second, but not in both)
set([1, 2, 4, 5])
>>>
Just like lists, sets also support comprehensions. Here is an example of how to use set comprehensions to find the unique consonants within a word:
>>> vowels = ['a', 'e', 'i', 'o', 'u']
>>> {x for x in 'maintenance' if x not in vowels }
set(['c', 'm', 't', 'n'])
A frozenset is basically just like a regular set, except that is immutable. It is created using the keyword frozenset, like this:
>>> frozen = frozenset([1, 2, 3])
You should choose to use a set in the following situations:
Tuples are immutable, but can hold mutable objects.
A tuple is represented by a number of values separated by commas. Unlike lists, tuples are immutable and the output is surrounded by parentheses so that nested tuples are processed correctly. Additionally, even though tuples are immutable, they can hold mutable data if needed.
Constructing an empty tuple requires parentheses. Here’s an example:
>>> my_empty_tuple = ()
>>> my_empty_tuple
()
Constructing a tuple with one element requires a trailing comma. Example:
>>> one_elem_tuple = 'a',
>>> one_elem_tuple
('a',)
>>> one_elem_tuple = ('a',)
>>> one_elem_tuple
('a',)
If the trailing comma is not there when creating a single element tuple, regardless if you use parentheses or not, Python will just interpret the value as a literal and will not create the tuple.
Constructing a tuple with multiple elements requires a list of values separated by commas. Here’s an example:
>>> s = 'a', 'b', [1, 2, 3]
>>> s
('a', 'b', [1, 2, 3])
>>>
Tuples, from a performance point of view are great because of their immutability. Python will know exactly how much memory to allocate for the data to be stored.
Dictionaries are represented by a key:value pair. In other words, they are maps or associative collections. The keys, unlike lists where they are numeric, can be of any immutable type and must be unique. The values can be of any type, mutable or immutable.
There are several ways to construct a dictionary. The most efficient way in terms of performance is to use curly braces {}:
>>> vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
>>> vowels
{1: 'a', 2: 'e', 3: 'i', 4: 'o', 5: 'u'}
Another way to create a dictionary is by using comprehensions. By using an input collection you can create the key:value pairs in one simple construct.
Here’s an example:
>>> {x:x*x for x in (1, 2, 3)}
{1: 1, 2: 4, 3: 9}
You can also use the keyword dict and get the same result. The dict construct takes as an argument, a list of key:value pairs. Here’s one in action:
>>> dict([(1,'a'), (2,'e'), (3,'i'), (4,'o'), (5,'u')])
{1: 'a', 2: 'e', 3: 'i', 4: 'o', 5: 'u'}
If the keys are strings, you can use the following keyword expression:
>>> dict(a=1, e=2, i=3, o=4, u=5)
{'i': 3, 'u': 5, 'e': 2, 'a': 1, 'o': 4}
However, it does not work the other way around when the keywords are numeric:
>>> dict(1=a, 2=e, 3=i, 4=o, 5=u)
File "<stdin>", line 1
SyntaxError: keyword can't be an expression
Accessing data in a dictionary is very straight forward, just wrap its key name within square brackets:
>>> vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
>>> vowels[1]
'a'
>>> vowels[10]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 10
>>>
As seen above, a KeyError occurs if the key doesn’t exist in the dictionary.
Also, a key:value pair can be deleted using the del keyword, like so:
>>> vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
>>> del(vowels[1])
>>> vowels
{2: 'e', 3: 'i', 4: 'o', 5: 'u'}
>>> del(vowels[10])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 10
>>>
Dictionaries support many built-in methods, but some of the most useful ones are: keys(), values(), iteritems(), itervalues(), and has_key().
Here’s an example:
>>> vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
>>> vowels.keys()
[1, 2, 3, 4, 5]
>>> vowels.values()
['a', 'e', 'i', 'o', 'u']
The methods iteritems() and itervalues() return iterators, so they can be used in for loops. Here’s an example:
>>> for k, v in vowels.iteritems():
... print k, v
...
1 a
2 e
3 i
4 o
5 u
>>> for v in vowels.itervalues():
... print v
...
a
e
i
o
u
>>>
key:value pair.dir and pass in a set object, you will see that it holds a lot of methods that can perform mathematical operations.dict offers less performance than using the curly braces ({}) syntax.IndexError and ValueError and dictionaries throw KeyError. This technique should help you with detecting which of your data structures is causing the error.