The use of packaging is common in Open Source projects through NPM, but there is also the possibility of publishing your own private packages so that they can be consumed by your applications without exposing them to all the world. We are used to working in closed and monorepo projects (or at least learning languages and frameworks under this operating mode), but it is increasingly common to divide the functionalities of a project by scope into packages, especially in relation to systems development design and components.
Let’s imagine that we are developing a design system or a component library in Angular and we want to use it in several projects. The initial idea is to create a project in Angular, develop the components, do a build and publish it in NPM. This has multiple drawbacks and several limitations:
You are exposing the complete code of the project
You are publishing an application made up of components, not the components themselves, with the derived performance problems.
NPM is a public package repository, so everyone would have access to that package.
To avoid these problems we can make use of two tools from Angular and GitHub: Angular Libraries and Github Packages.
In user-centered design, designers use a mixture of investigative methods and tools (e.g., surveys and interviews) and generative ones (e.g., brainstorming) to develop an understanding of user needs.
Generally, each iteration of the UCD approach involves four distinct phases. First, as designers working in teams, we try to understand the context in which users may use a system. Then, we identify and specify the users’ requirements. A design phase follows, in which the design team develops solutions. The team then proceeds to an evaluation phase. Here, you assess the outcomes of the evaluation against the users’ context and requirements, to check how well a design is performing. More specifically, you see how close it is to a level that matches the users’ specific context and satisfies all of their relevant needs. From here, your team makes further iterations of these four phases, and you continue until the evaluation results are satisfactory.
Online surveys are a quick and incredibly useful tool for gathering all sorts of user feedback. In next to no time you can whip something up using one of the many online survey tools out there (I particularly recommend SurveyGizmo) and start gathering feedback from real users. Often implementing the survey is the easy bit, it’s designing the thing that’s the tricky part as you won’t get the feedback you’re after if you don’t ask the right questions. In this article I outline 15 useful user feedback questions for online surveys for you to pick and choose from.
Rather than attempting to eliminate error cases, use your iterative design process to understand failure modes and design for them. You should seek to understand failure cases in two ways. First, to identify whether an ‘escalation’ or executive judgment is required. In certain cases such as fraud detection, a user that attempts to correct an erroneous fraud label needs a streamlined way to do so, as these exceptional cases can be highly stressful! Second, you can use iterative design to better understand your own criterion of success. Many problems don’t have a binary true-false answer. Sometimes, in cases such as recommendation, quality follows a gradient from terrible to excellent.
A design language is a standard way to communicate a set of concepts so that people don’t have to re-learn things over and over. They make roads easier to drive on, kitchen utensils easier to use, and technology more intuitive. Every time you tap on a button on a website and see the button change color to signal that you ‘clicked’ it, you’re interfacing with a design language. Design can bring clarity, intuition, and usability to these kinds of experiences. But more importantly, design is a lens with which we should make change in the world.
Like many things in UI design, something that appears random and subjective (like font sizes) is actually depending on remarkably sensible principle: we like to read paragraphs whose letters are about the same subjective size – namely, something like 0.3° tall, from baseline to cap height, in our field of vision.
First, why are we measuring font sizes in degrees? Frankly, it’s the most sensible way to do it when comparing across devices. What else you got – inches? If you talk about trying to make your type half an inch tall, well, great, but half an inch text is crazy big on a phone (one foot from your face), and pretty small on a TV screen (10 feet from your face). The simple truth is: when a font is twice as far away, it needs to be twice as big to compensate.
Now this is great in theory, but in practice, it’s incredibly arduous to calculate:
Not everyone views their phone or monitor from the same distance
Not all devices have the same size pixels
Not all fonts are the same readability – even at the same font size, pixel-density, and viewing distance!
So while you will probably never be calculating this out by hand, I think there are two general lessons that are worth bearing in mind.
The 1/16” Rule
Across a wide variety of viewing distances, you can size your body text according to the following formula:
Font size (in inches) = 1/16" x (the number of feet between the user’s eyeballs and the device)*
*Measuring baseline to cap height, and presuming a fairly readable body font
I don’t expect you to whip out a ruler the next time you make an Android app, but this could come in handy when you take your digital design knowledge to a medium you’ve never worked with: presentation posters, TV apps, slideshows for viewing in an auditorium hall, etc.
The Pixel Density-Viewing Distance Offset
In general, smaller devices have smaller pixels*.
*By “pixel”, I mean not physical pixels, but the concept alternatively referred to as “CSS pixels” (web), “density-indepent pixels” (Android), or “points” (iOS) – in-depth explanation here.
That means smaller devices have more pixels per inch. And that means the same font size appears physically smaller on phones than tablets, and physically smaller on tablets than desktops (and so on for TVs as well, by the way).
That’s not the end of the world, since we hold phones closer to our face. But if the average phone is twice as close to our eyeballs as the average desktop, is the pixel density decrease enough on desktop to make the desktop font twice as big? Short answer: no. Longer answer: as of writing, the typical desktop now has about 33% smaller pixels than your typical mobile device. This means that it’s not stupid to make any desktop text about 33% larger than its mobile equivalent, at least on a page optimized for long form reading.
Here’s a quick summary of styles. See below for visual reference and more in-depth guidelines.
Element
Sizing
Notes
Page titles, Modal titles
17pt
Medium font weight iOS 10+ page titles are 34pt before scrolling, 17pt once scrolled
Paragraph text, Links
17pt
Secondary text
15pt
Lighter color as well
Tertiary text, Captions, Segmented buttons
13pt
Skip a font size between secondary and tertiary text
Buttons, Text inputs
17pt
Highlight important buttons with medium font weight
Action Bar
10pt
Don't go smaller than this
Let’s break this down element-by-element and look at illustrated examples. We’ll cover not just the actual font sizes, but also how Apple thinks about text styles.
The sizes are listed as:
iPad Pro, iPad, iPad mini About 44px by 44px
iPhone 6,7,8s, iPhone 6, iPhone SE About 44px by 44px
iPhone 6,7,8s Plus, iPhone 6 Plus About 66px by 66px
The difference is because the iPhone 6,7,8[s] Plus uses the @3x resources while the others use the @2x images. So your @2x and @3x sizes are correct, your @1x image should however be half the size of your @2x image.
Apple and Android dominate the smartphone market, owning over 90 percent of the industry.
To take advantage of this fact, many companies that already have an app based on one platform look to make it work across both Apple and Android devices. But this isn't as easy as it sounds, and taking shortcuts to do so can have serious consequences.
