asp.net mvc 5 and the web api pdf : Add pdf files together control Library platform web page asp.net winforms web browser microinteractions_sample_CH11-part1513

Figure 1-4. Tapbot’s Convertbot is an app built around a single microinteraction: con‐
verting one value to another.
Microinteractions are frequently the last parts of a product to be designed and devel‐
oped, and as such they are often overlooked. But ignoring them is a mistake. The reason
the original (G1) version of Android felt so unpolished was because the microinterac‐
tions were clunky, especially in comparison to the iPhone; for example, deleting items
was inconsistently triggered, and in some applications pressing the search key did noth‐
ing at all. If the microinteractions are poor, the main features, no matter how nicely
done, are surrounded by pain and frustration. The design of your product is only as
good as its smallest part.
Consider that almost all operating systems, be they mobile or desktop, do basically the
same things: install and launch applications, manage files, connect software to hardware,
manage open applications and windows, etc. But the difference between operating sys‐
tems—at least from a user’s perspective—are the microinteractions you have with it on
a daily, even hourly, basis (see Figures 1-5 and 1-6).
6 | Chapter 1: Designing Microinteractions
Add pdf files together - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
merge pdf files; pdf merge files
Add pdf files together - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
reader combine pdf; append pdf files reader
Figure 1-5. The author’s menu bar in OS X is crammed full of icons, each of which
launches a microinteraction.
Of course, some features are so useful and/or powerful (or so highly protected by in‐
tellectual property laws) that the microinteractions don’t matter as much. Many medical
devices are examples of this, as is most early stage technology, when people are more
amazed something can be done rather than how it’s done. For instance, the first gener‐
ation of the Roomba (introduced in 2002) couldn’t calculate room size or detect obstacles
and dirt, but it was a novel technology nonetheless, and subsequent models (especially
now that there are competitors on the market) have focused more on the human–robot
microinteractions.
Figure 1-6. When trying to find a word on a page, Chrome indicates in the scrollbar
where instances of that word appear. (Courtesy Saul Cozens and Little Big Details.)
In competitive markets, microinteractions are even more important. When there is
feature parity, it is the experience using the product that increases adoption and brand
loyalty. The overall experience of a product relies heavily on its microinteractions. They
are the “feel” in look-and-feel. One reason Google+ fell so flat against Facebook was that
its microinteractions, such as sorting users into circles, while initially intriguing, quickly
became tiresome and gimmicky.
Another reason to pay attention to microinteractions is because they fit so well into our
multiplatform existence. Microinteractions are the glue that can tie together features
across mobile devices, TV, desktop and laptop computers, appliances, and the Web.
While the microinteractions could vary by platform, their small size allows for a con‐
sistency that you might not have with large features. In particular, appliances and mobile
Microinteractions Are Not Features ... But Still Matter | 7
C# Word - Merge Word Documents in C#.NET
empowers C# programmers to easily merge and append Word files with mature input Word documents can be merged and appended together according to Add references:
break pdf into multiple files; attach pdf to mail merge in word
C# PowerPoint - Merge PowerPoint Documents in C#.NET
together according to its loading sequence, and then saved and output as a single PowerPoint with user-defined location. C# DLLs: Merge PowerPoint Files. Add
c# merge pdf; acrobat combine pdf
devices with their small (or no) screens seem custom-made for microinteractions. Small
interactions work well on small devices.
Take Twitter for example. Twitter is built entirely around a single microinteraction:
sending a <140-character message. Users can do this from practically any device, any‐
where. Some objects even tweet independently, or for us. Twitter can be used to send
gossip or messages to coordinate a revolution. Well-designed microinteractions can
scale well across platforms and to millions of users (see Figure 1-7).
Figure 1-7. A nice piece of microcopy. When you go to ask for support at Harvest, it
shows the time at their office alongside their office hours. (Courtesy Nicolas Bouliane.)
Microinteractions also fit well into our already crowded, overcomplicated, and frag‐
mented lives. We need and even enjoy the fast glance at data, the rapid check-in at a
restaurant, the casual review of messages on the subway. (The “Casual Games” category
is really a set of stand-alone microinteractions for amusement.)
Microinteractions force designers to work simply, to focus on details. They challenge
designers to see how lightweight they can design, to reduce complexity and streamline
features that could otherwise be burdensome (Figure 1-8).
Figure 1-8. In Microsoft Office, when text is rotated, relevant styling buttons are rota‐
ted as well. (Courtesy Little Big Details.)
8 | Chapter 1: Designing Microinteractions
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
can be copied and pasted to .txt files by keeping text by a method loses the original PDF document layout and all the paragraphs are joining together, our C#
merge pdf online; combine pdf online
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
Imaging.MSWordDocx.dll", which, when used together with other online tutorial on how to add & insert controls, PDF document, image to pdf files and components
add pdf together; pdf mail merge plug in
3. Detailed in Bravo Course Outline by Suzan Jerome, published by Xerox, 1976.
The Secret History of Microinteractions
In 1974, a young engineer named Larry Tesler began working on an application called
Gypsy for the Xerox Alto computer. Gypsy was one of the first word-processing appli‐
cations ever, and the successor to the groundbreaking Bravo, the first true WYSIWYG
word-processing program and the first program that could have the ability to change
fonts. Even though it was still a word-processing program, Gypsy was a different kind
of application altogether: it made use of a mouse and a graphical user interface (GUI).
Larry’s mission—and what would become his rallying cry for decades to come—was to
reduce the modality of the interface, so that users wouldn’t have to switch to a separate
mode to perform actions. (His website is http://www.nomodes.com, his Twitter handle
is @nomodes, and even his license plate reads NOMODES.) Larry wanted users, when
they typed a character key, to always have that character appear onscreen as text—not
an unreasonable expectation for a word-processing application. This wasn’t the case in
Bravo: typing only worked in a particular mode; other times it triggered a function.
One of those functions was moving text from one part of the document to another. In
Bravo (see Figure 1-9), users had to first select the destination, then press the “I” or “R”
keys to enter Insert or Replace modes, then find and select the text to move, then finally
press the Escape key to execute the copy.
3
Larry knew there was a better way to perform
this action, so he designed one that not only made use of the mouse, but radically
simplified this microinteraction. In Gypsy, the user could select a piece of text, press the
“Copy” function key, then select the destination, and finally press the “Paste” function
key. No mode required. And thus, cut and paste was born.
The intertwined history of interaction design and human–computer interaction is really
the history of microinteractions. The tiny things we unthinkingly interact with every
day on desktops, laptops, and mobile devices were once novel microinteractions: ev‐
erything from saving a document to organizing files into folders to connecting to a WiFi
network were all microinteractions that needed to be designed. Even “basics” like scroll‐
ing and opening multiple windows needed to be designed and engineered. The forward
march of technology has provided a continuous need for new microinteractions. We
use them unquestioningly now, and only really pay attention to them when someone
designs a better way, or the technology changes and allows for or forces a new way of
performing the microinteraction.
The Secret History of Microinteractions | 9
C# Excel - Merge Excel Documents in C#.NET
and appended together according to its loading sequence, and then saved and output as a single Excel with user-defined location. C# DLLs: Merge Excel Files. Add
combine pdf files; all jpg to one pdf converter
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
Support converting other files to Tiff, like Word, Excel, PowerPoint, PDF, and images. Enable to add XImage.OCR for .NET into C# Tiff imaging application
add pdf files together; combine pdfs online
Figure 1-9. A “screenshot” (Polaroid[!]) of Bravo. The bottom window is being used to
make a form in the top window. (Courtesy DigiBarn Computer Museum.)
Indeed, as technologies have changed, the microinteractions that support them have
also changed. Take scrolling, for instance. Bravo had a primitive version of scrolling,
but scrolling really became more refined when Alan Kay, Adele Goldberg, and Dan
Ingalls introduced scrollbars in another Xerox PARC product, SmallTalk, sometime
between 1973 and 1976. SmallTalk’s scrolling could be smooth, pixel-by-pixel, instead
of line-by-line. (This was famously one of the UI elements demoed to Steve Jobs and
10 | Chapter 1: Designing Microinteractions
C# Image: C# Code to Encode & Decode JBIG2 Images in RasterEdge .
Easy to add C# JBIG2 codec controls to your image and codec into PDF documents for a better PDF compression; text to the new project folder, together with .NET
pdf split and merge; c# combine pdf
VB.NET PDF Text Search Library: search text inside PDF file in vb.
and find text content in multiple page adobe PDF files in .NET Our VB.NET PDF Document Add-On enables you to search for text in target PDF document by using
pdf merger; acrobat merge pdf files
4. As recounted in Dealers of Lightning: Xerox PARC and the Dawn of the Computer Age by Michael A. Hiltzik
(HarperBusiness, 2005).
his engineers, which they then built into Apple’s Lisa (Figure 1-10)—and subsequently
the Macintosh.)
4
As documents got longer, scrollbars added arrows to jump to the end without scrolling.
Tooltip-style indicators would appear to indicate where you were in the document. But
the real change came with touchscreen technology on trackpads and mobile devices.
Do you slide up or down to scroll down? Apple famously changed directions (from
down to up) in OS X Lion after the introduction of its iPhones in order to align its
laptops and mobile devices to “natural scrolling.” [See, for example, “Apple’s Mousetrap:
Why did Apple reverse the way we scroll up and down?” by Michael Agger in Slate.]
Apple has also (to the ire of many) hidden scrollbars except when scrolling is in process
or the cursor nears the right edge of a scrollable window. The microinteraction keeps
evolving.
Figure 1-10. Apple’s Lisa (1982) featured dozens of “new” (for the market) microinter‐
actions. (Source: Lisa Graphical User Interface Gallery Guidebook.)
The Secret History of Microinteractions | 11
But it’s not just digital products that have microinteractions; a case can be made that
microinteractions originated with the first electric devices, such as the radio (1893), the
flashlight (1986), and the washing machine (1900). As designer Bill DeRouchey points
out in his talk “The History of The Button,” in the (pre-electric) mechanical era, users
could follow their actions directly from the control to the output. You could pull a lever,
watch the gears move and finally see the wheels turn. It was easy to connect the input
to the output. Electricity changed all that. You could press a button on the wall and
nearly instantly a light on the other side of the room turned on. Sure, the feedback was
instant, but the method of execution was not. As DeRouchey says in “The History of
the Button”, “The button meant for the first time the result of the human motion could
be completely different from the motion [it creates] itself.” Action became abstracted.
In the digital age, particularly before the GUI, action became even more abstract. In‐
serting a stack of punchcards or flipping a series of switches produced output that was
equally obtuse. For a time, the GUI cleared up and simplified microinteractions. But
then Moore’s Law (processor speed doubles every 18 months), Koomey’s Law (power
consumption for hardware decreases 50% every 18 months), Kryder’s Law (exponential
increase in storage space), and increasing bandwidth and network connectivity (LANs
first, then wireless networks, both local and mobile) created the need for more micro‐
interactions, and those microinteractions needed to control actions far more abstract
than turning on a light. Just as one example, syncing data across devices is a conceptually
abstract idea, for which there’s no readily available physical analog.
Input methods are also drastically changing microinteractions. Not only do we have
physical controls like buttons, switches, keyboards, and mice, we also have touchscreens,
sensors, voice, and gestural means of triggering microinteractions. In the not-too-
distant past, the only way to interact with the physical environment was to adjust it
manually via a physical control. This changed in 1956 when Robert Adler invented the
Zenith Space Commander, the first TV remote control (Figure 1-11). For the first time,
users could control an object from a distance, invisibly.
Today, to trigger a microinteraction, you don’t even need to be in the same room. With
the right equipment, you can adjust the temperature in your house from the other side
of the world (see Figure 1-12). Or you only need to be in the right location; just by being
in a certain block, your mobile phone can remind you of a to-do item, or your GPS
device can tell you where to turn left. In public restrooms, you can turn on sinks just
by putting your hands into them. You can tell your phone to find you a nearby restaurant,
or flick your finger down a touchscreen list to reveal a search bar, or tap your phone on
a counter to pay for your coffee. The list goes on.
The history of technology is also the secret history of the microinteractions that, like
symbiotic organisms, live alongside them to frame, manage, and control them.
12 | Chapter 1: Designing Microinteractions
Figure 1-11. Although there had been remote-control planes and boats previously
(mostly for military use), the Space Commander television remote removed proximity
from control for consumers. (Courtesy Peter Ha.)
Figure 1-12. The Nest Learning Thermostat uses proximity sensors to know when some‐
one walks into the room, then lights up and shows the temperature in a way that’s visi‐
ble at a glance from across the room. No touching required. (Courtesy of Nest.)
The Secret History of Microinteractions | 13
The Structure of Microinteractions
What makes effective microinteractions is not only their contained size, but also their
form. A beautifully crafted microinteraction gracefully handles four different parts,
which will be described next (see Figure 1-13).
Figure 1-13. The structure of microinteractions.
These four parts—the trigger that initiates the microinteraction, the rules that determine
how the microinteraction works, the feedback that illuminates the rules, and loops and
modes, the meta rules that affect the microinteraction—are a way to design and dissect
microinteractions.
The first part of any microinteraction is the trigger. With turning off the ringer on an
iPhone, the trigger is user-initiated, meaning that the user has to do something—in this
case, flip a switch—to begin the microinteraction. Thus, many microinteractions begin
with an understanding of user need: what the user wants to accomplish, when they want
to do it, and how often. This determines the affordances, accessibility, and persistence
of the trigger. In our silencing-the-phone example, turning off the ringer is a very com‐
mon action that users want to perform all the time, rapidly. Thus the trigger (the Ringer/
Silent switch) is available all the time, instantly able to be turned on and off no matter
what application is running. It was so important, it’s one of only five physical controls
on the iPhone. Controls—digital and/or physical—are the most important part of user-
initiated triggers. They provide not only the ability to engage with a microinteraction
(and sometimes the ability to adjust it while in progress), but also usually the visual
affordance that the microinteraction is even there (see Figure 1-14). If there were no
ringer on/off switch on the iPhone, you might expect the phone had that functionality,
but have to guess at where to find it. In many older mobile phones (and even in some
phones still), silencing the phone was buried under several layers of a settings menu.
Even for users who knew where the setting was, it took as much as 10 seconds to turn
the ringer on or off. It takes less than a second to flip the physical Ringer/Silent switch.
Of course, the physical control doesn’t have to be a switch either. Although the best
designs feel inevitable, there is almost nothing designed that could not be designed
differently. On Windows Phones, the trigger is a pressable rocker button (which also
controls volume) that, when pressed, presents users with a screen overlay that lets users
choose ringer status as “vibrate” or “ring + vibrate.”
14 | Chapter 1: Designing Microinteractions
Figure 1-14. An example of a trigger. In iOS (as in Windows Mobile), you can use the
camera even on a locked phone. Pressing the camera icon bounces the bottom bar up a
little, indicating that you swipe up to get the camera functionality. Of course, slide to
unlock is its own trigger as well.
But triggers need not be user-initiated. Increasingly, triggers are system-initiated—
when the device or application itself detects that certain conditions have been met and
begins a microinteraction. The triggering condition could be anything from detecting
that a new email arrived, to the time of day, to the price of a particular stock, to the
location of the user in the world. For silencing the phone, one could easily imagine that
function integrating with your calendar, so that it automatically silences the phone
whenever you’re in a meeting. Or by knowing your location, it automatically goes silent
whenever you’re in a movie theater or symphony hall. As our applications and devices
become more sensor-full and context-aware, the more ability they could have to make
decisions on their own about how they operate.
The Structure of Microinteractions | 15
Documents you may be interested
Documents you may be interested