create and print pdf in asp.net mvc : Convert pdf to tiff format software Library cloud windows .net html class Ko2010EndUserSoftwareEngineering2-part1860

21 
Finally, some approaches for writing specifications take a direct manipulation, what 
you see is what you get (WYSIWYG) approach, moving the description of behavior and 
appearance to the user’s language, rather than a machine language. For example, many 
WYSIWYG web site tools allow users to directly manipulate the design of a web site and 
then let the tool generate the HTML and CSS for use in a web browser (most notably at 
the time of this writing is Adobe’s Dreamweaver). To enable direct manipulation, such 
tools often limit the range of design possibilities to facilitate code generation, requiring 
users to learn the underlying language to express more complicated designs.  
3.2.3. Inferring specifications. One approach to the problem of how to support a de-
e-
sign process is to eliminate it, replacing it with technologies that can determine require-
-
ments automatically through various forms of inference. 
Several systems have used a programming by example approach to this problem (such 
systems are described in detail in [Lieberman 2000]). These systems allow users to pro-
vide multiple examples of the program’s intended behavior and the tool observes the be-
havior and attempts to generalize from it. For example, Abraham and Erwig developed an 
approach for automatically inferring the templates discussed in the previous section from 
an example spreadsheet [Abraham and Erwig 2006a], allowing users more flexibility in 
redefining the spreadsheet template as requirements change. In the domain of event-based 
simulations, the AgentSheets environment [Repenning and Perrone 2000] lets the pro-
grammer specify that a new type of “part” is just like an existing part, except for its icon; 
the tool will then generate all of the instructions necessary for the new part. McDaniel 
and Myers [1999] describe an approach to inferring interaction specifications, allowing 
users to click and drag objects from one part of the screen to another to demonstrate a 
desired movement at runtime.  
Recent work has begun to apply programming by example to web sites. For example, 
Toomim et al. [2009] allow users to select example data from web sites and automatically 
generate a range of user interface enhancements. Nichols and Lau [2008] describe a simi-
lar system, which allows users to create a mobile version of a web site through a combi-
nation of navigating through the desired portion of the site and explicitly selecting con-
tent. Macias and Paterno [2008] take a similar approach, in which users directly modify 
the web page source code. These modifications are used as a specification of preferences, 
which are then generalized and applied to other pages on the same site. Yet another ap-
proach allows users to identify the same content with multiple markings, increasing the 
robustness of the inference [Lingham and Elbaum 2007]. 
Convert pdf to tiff format - software Library cloud:C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net, ASP.NET MVC, Ajax, WinForms, WPF
Online C# Tutorial for How to Convert PDF File to Tiff Image File
www.rasteredge.com
Convert pdf to tiff format - software Library cloud:VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.net, ASP.NET MVC, Ajax, WinForms, WPF
Free VB.NET Guide to Render and Convert PDF Document to TIFF
www.rasteredge.com
22 
One problem with programming by example approaches is that the specifications in-
ferred are difficult to reuse in future programs, since most systems do not package the 
resulting program as a reusable component or a function There are some exceptions to 
this, however. For example, Scaffidi et al. [2007] describe an approach to inferring data 
type specifications from unlabeled textual examples and then allowing users to review 
and customize the specification. The specification can then be easily packaged and reused 
for use in other applications. Another counter example is [Smith et al. 2000]. 
An alternative to programming by example is to elicit aspects of the specification di-
i-
rectly from end users. Burnett et al. [2003] describe an approach for spreadsheets, attach-
ing assertions to each cell to specify intended numerical values. In this approach, seen in 
Figure 5, users can specify an intended range of a cell’s value at any time. Then, the sys-
-
tem propagates these ranges through cell formulas, allowing the system to further reason 
about the correctness of the spreadsheet. If a conflict is found between a user-generated 
assertion and a system-generated assertion, the system circles the two assertions to indi-
-
cate the conflict. This assertions-based approach has been shown to increase people’s 
effectiveness at testing and debugging [Wilson et al. 2003, Burnett et al. 2003]. Scaffidi 
describes a similar approach for validating textual input [Scaffidi et al. 2008]; we de-
scribe this approach in Section 3.3.4. 
Other approaches take natural language descriptions of requirements and attempt to 
translate them into code. For example, Liu and Lieberman [2005] describe a system that 
Figure 5. An assertion conflict in Forms/3. The user wrote the assertion on the Celsius cell (0 to 100), which 
conflicts with the computer generated assertion (0 to 500). This prompts the user to check for errors in the cells’ 
formulas [Burnett et al. 2003]. Original figure obtained from authors. 
software Library cloud:C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
forms, including Jpg, Png, Bmp, Gif, Tiff, Bitmap, .NET load a program with an incorrect format", please check can use this sample code to convert PDF file to
www.rasteredge.com
software Library cloud:C# PDF Convert to SVG SDK: Convert PDF to SVG files in C#.net, ASP
In some situations, it is quite necessary to convert PDF document into SVG image format. Here is a brief introduction to SVG image.
www.rasteredge.com
23 
takes descriptions of the intended behavior of a system and generates Python declarations 
of the objects and behaviors described in the descriptions. Little and Miller [2006] devel-
-
oped a similar approach for Chickenfoot [Bolin et al. 2005] (a web scripting language) 
and Microsoft Word’s Visual Basic for Applications. Their approach exploits the user’s 
familiarity with the vocabulary of the application domain to express commands in that 
domain. Users can state their goals in terms of the domain keywords that they are familiar 
with and the system generates the code. Other systems have attempted to teach com-
-
mands to users when their effect may not be visible, as in the case of scriptable group-
ware applications [Wulf 2000]. 
3.3. What Can I Use to Write My Program? — Reuse 
Reuse generally refers to either a form of composition, such as “gluing” together compo-
-
nents APIs, or libraries, or modification, such as changing some existing code to suit a 
new context or problem. In professional programming, most of the code that developers 
write  involves reuse of some sort, whether copying code  snippets, adapting example 
code, or using libraries and frameworks by invoking their APIs [Bellon et al. 2007]. Tra-
a-
ditionally, the motivations for these various types of reuse are usually to save time, to 
avoid the risk of writing erroneous new code, and to support maintainability [Ye and 
Fischer 2005, Ravichandran and Rothenberger 2003]. 
While these practices are also true in end-user programming, in many ways they are 
made more difficult by end users’ shift in priorities. In particular, finding, reusing, and 
even sharing code becomes more opportunistic, as the goals of reuse are more to save 
time and less to achieve other software qualities. Furthermore, in end-user programming, 
reuse is often what makes a project possible, since it may be easier for an end user to per-
form a task manually or not at all than to have to write it from scratch without other code 
to reuse [Blackwell 2002a].  
Prior work on reuse has largely focused on studies of reuse in more conventional pro-
gramming languages with large APIs or object hierarchies. Consequently, many of the 
challenges that professionals face, end users face as well. Where these populations differ 
is in how APIs, libraries, and frameworks must be designed to support a certain popula-
tion. While APIs designed for professionals use often focus on optimizing flexibility, end 
users often need much more focused support for achieving their domain-specific goals. In 
this section, we characterize prior work on these different reuse activities and compare 
and contrast the role of reuse in end-user programming and professional development. 
software Library cloud:VB.NET Image: Tutorial for Converting Image and Document in VB.NET
image and document formats, including PDF, TIFF, GIF, BMP, JPEG and so on. When using this VB.NET Image Conversion SDK to convert image, image format and its
www.rasteredge.com
software Library cloud:How to C#: File Format Support
File Format Supported. Load, Save Document. Preview Document. Conversion. Convert PowerPoint to PDF. Convert PowerPoint to HTML5. Convert PowerPoint to Tiff. Convert
www.rasteredge.com
24 
3.3.1. Finding Code to Reuse.  A fundamental challenge to reuse is finding code and 
nd 
abstractions to reuse or knowing that they exist at all [Ye and Fischer 2005]. For exam-
m-
ple, Ko found that students using Visual Basic.NET to implement user interfaces strug-
gled when trying to use search tools to find relevant APIs, and instead relied on their 
more experienced peers for finding example code or APIs [Ko et al. 2004]. This is similar 
to Nardi’s finding that people often seek out slightly more experienced coworkers for 
programming help [Nardi 1993]. Example code and example programs are one of the 
greatest sources of help for discovering, understanding, and coordinating reusable ab-
stractions,  both  in  professional  programming  [Rosson  and  Carroll  1996,  Stylos  and 
and 
Myers 2006]  and end-user programming [Wiedenbeck 2005,  Rosson et al. 2005]. In 
. In 
many cases the examples are fully functional, so the programmer can try out the exam-
ples  and better  understand  how  they  work  [Rosson  and  Carroll  1996,  Walpole  and 
Burnett 1997]. 
Researchers have also invented a number of tools to help search for both example 
code and APIs. For example, the CodeBroker system watches the programmer type code 
and guesses what API functions the programmer might benefit from knowing about [Ye 
and Fischer 2005]. Other systems also attempt to predict which abstractions will benefit a 
professional programmer [Mandelin et al. 2005, Bellettini et al. 1999]. Mica [Stylos and 
Myers 2006] lets users search using domain-specific keywords. While all of these ap-
p-
proaches are targeted at experienced programmers, many of the same ideas are beginning 
to be applied to languages intended for end-user programming. For example, CoScrip-
-
ter’s support for sharing and finding others’ scripts not only helps users search for exam-
m-
ples, but utilizes other meta data such as a users’ social network to help users find rele-
-
vant programs [Bogart et al. 2008]. 
3.3.2. Reusing Code. Even if end users are able to find reusable abstractions, in some 
cases, they may have difficulty using abstractions that were packaged, documented, and 
provided by an API. One study of students using Visual Basic.NET for user interface 
prototype showed that most difficulties relate to determining how to use abstractions cor-
rectly, coordinating the use of multiple abstractions, and understanding why abstractions 
produced certain output [Ko et al. 2004]. In fact, most of the errors that the students made 
had more to do with the programming environment and API, and not the programming 
language. For example, many students had difficulty knowing how to pass data from one 
window to another programmatically, and they encountered null pointer exceptions and 
other inappropriate program behavior. These errors were due primarily to choosing the 
software Library cloud:VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Why do we need to convert PDF document to HTML webpage using VB.NET programming code? PDF, known as Portable Document Format, has been widely used by
www.rasteredge.com
software Library cloud:How to C#: File Format Support
to Start. Basic SDK Concept. File Format Supported. Load, Save Document. Preview Document. Conversion. Convert Word to PDF. Convert Word to HTML5. Convert Word
www.rasteredge.com
25 
wrong API construct or violating usage rules in the coordination of multiple API con-
structs. Studies of end-user programming in other domains, such as web programming 
[Rode et al. 2003, Rosson et al. 2004], and numerical programming [Nkwocha and El-
l-
baum 2005], have documented similar types of API usage errors. 
There are several ways of addressing mismatch between code and the desired func-
tionality. In the case of code, one way is to simply modify the code itself, customizing it 
for a particular purpose. A special case of adapting such examples is the concept of a 
template. For example, Lin and Landay [2008], in their tool for prototyping user inter-
faces across multiple devices, provide a collection of  design  pattern examples [Beck 
2007] that users can adapt, parameterize, and combine. Some end-user development plat-
t-
forms, such as Adobe Flash, implement user interface components as modifiable tem-
plates. Templates have also been used to facilitate the creation of scripts for mobile de-
vices to support the independencies of people with cognitive disabilities [Carmien and 
Fischer 2008]. 
The mismatch between code and desired functionality can sometimes be addressed 
through tailoring by the end user. In this case, the user supplies parameters, rules, or even 
more complex information to the component or application, thereby changing its behav-
v-
ior. Tailoring enables component developers to offload some adaptive maintenance ac-
tivities onto end users [Dittrich et al. 2006], who essentially become asynchronous col-
-
laborators with the component developers [Mørch and Mehandjiev 2000]. In order for a 
component to be tailorable, the component designer must engage in significant upfront 
planning; in particular, the designer must consider how users in the target population will 
differ from one another, then determine which aspects of the component should accord-
ingly be tailorable [Dittrich et al. 2006]. There are several ways to uncover user needs, 
such as including users in the design and construction of the component [Letondal 2006], 
performing ethnographies [Stevens et al. 2006], or interviewing users about their likely 
requirements [Eagen and Stasko 2008]. Such approaches assume that the users involved 
in component design can represent the diverse needs of the target population. Since users 
often vary not only in their requirements, but also in their level of tailoring skill, some 
component designers provide multiple mechanisms for tailoring, so that users with more 
skill can take advantage of more complex mechanisms in order to effect more specialized 
tailoring [Eagan and Stasko 2008, Morch and Mehandjiev 2000, Wulf 1999, Wulf  et al. 
et al. 
2008]. Tailorability can be greatly facilitated by integrated support for collaborated tailor-
ing [Pipek  and Kahler 2006], integrity checks for detecting tailoring mistakes [Won et al. 
software Library cloud:C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
DocumentType.DOCX DocumentType.TIFF. zoomValue, The magnification of the original PDF page size. Description: Convert to DOCX/TIFF with specified resolution and
www.rasteredge.com
software Library cloud:C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
a program with an incorrect format", please check new PDFDocument(@"C:\input.pdf"); pdf.ConvertToVectorImages(ContextType Description: Convert to html/svg files
www.rasteredge.com
26 
2006, Wulf et al. 2008], and evaluation features for helping users to understand the im-
-
pact of tailoring [Won et al. 2006, Wulf et al. 2008]. 
Actually modifying the source code of APIs, libraries and other kinds of abstractions 
is generally not possible, since the code for the abstraction itself is not usually available. 
The programmer can sometimes write additional code to adapt an API [DeLine 1999], 
but there are certain characteristics of APIs and libraries, such as performance, that are 
difficult to adapt. Worse yet, when an end-user programmer is trying to decide whether 
some API or library would be suitable for a  task, it is difficult to know in advance 
whether one will encounter such difficulties (this is also true for professionals [Garlan et 
al. 1995]). 
Another issue for API and abstraction use is whether future versions of the abstraction 
will introduce mismatch because of changes to the implementation of the API behavior. 
For example, ActionScript [DeHaan 2006] (the programming language for Adobe Flash) 
and spreadsheet engine upgrades often change the semantics of existing programs’ be-
havior. In the world of professional programming, one popular approach to detecting 
such changes is to create regression tests [Onoma et al. 1988]. Another possibility is to 
proxy all interactions with the API and log the API’s responses; then, if future versions of 
the API respond differently, the system can show an alert [Rakic and Medvidovic 2001]. 
Regression testing has been used in relation to spreadsheets [Fisher et al. 2002b]; beyond 
this, these approaches have not been pursued in end-user development environments. 
3.3.3. Creating and Sharing Reusable Code. Thus far, we have discussed reusing ex-
x-
isting code, but most end-user programming environments also provide ways for users to 
to 
create new abstractions. Table 3 lists several examples of reusable abstractions, distin-
n-
guishing between behavioral abstractions and data abstractions. Studies of certain classes 
of end users suggest that data abstractions are the most commonly created type [Rosson 
et al. 2005, Scaffidi et al. 2006]. 
27 
Although end users have the option of creating such reusable abstractions, examples 
are  the  more  common  form  of  reusable  code.  Unfortunately,  it  is  extremely  time-
consuming to maintain a well-vetted repository of code. For example, Gulley [2006] de-
-
scribes the challenges in maintaining a repository of user-contributed Matlab examples, 
with a rating system and other social networking features. For this reason, many organi-
zations do not explicitly invest in creating such repositories. In such cases, programmers 
cannot rely on search tools but must instead share code informally [Segal 2007, Wieden-
beck 2005]. This spreads repository management across many individuals, who share the 
work of vetting and explaining code. 
Although it is common for end-user programmers to view the code they create as 
“throw away,” in many cases such code becomes quite long-lived [Mackay 1990]. Some-
Some-
one might write a simple script to streamline some business process and then later, some-
one might reuse the script for some other purpose. This form of “accidental” sharing is 
one way that end-user programmers face the same kinds of maintainability concerns as 
professional programmers. In field studies of CoScripter [Leshed et al. 2008, Bogart et al. 
2008], an end-user development tool for automating and sharing “how-to” knowledge, 
e, 
scripts in the  CoScripter repository  were regularly  copied  and  duplicated  as starting 
points for new scripts, even when the original author never intended such use [Bogart et 
Environment 
Domain  Behavioral abstractions 
Data abstractions 
AutoHAN 
[Blackwell and Hague 2001] 
Home 
automation 
Channel Cubes can map to scripts 
that call functions on appliances. 
Aggregate Cubes can represent 
a collection of other Media 
Cubes. 
BOOMS 
[Balaban et al. 2002] 
Music 
editing 
Functions record series of music 
edits. 
Structures contain notes and 
phrases.  
Forms/3 
[Burnett et al. 2001]  
Spread-
sheets  
Forms simultaneously represent a 
function and an activation record. 
Types are structured collections 
of cells and graphical objects. 
Gamut
[McDaniel  and Myers 1999]
Game 
design 
Behaviors are learned from posi-
tive and negative examples. 
Decks of cards serve as graphi-
cal containers with properties. 
Janus 
[Fischer and Girgensohn 1990] 
Floor plan 
design 
Critic rules encode algorithms for 
deciding if a floor plan is “good.” 
Instances of classes may pos-
sess attributes and sub-objects. 
KidSim 
[Smith et al. 1994] 
Simulation 
design 
Graphical rewrite rules describe 
agent behavior. 
Agents possess properties and 
are cloned for new instances. 
Lapis 
[Miller and Myers 2002] 
Text edit-
ing 
Scripts automate a series of edits.  Text patterns can contain sub-
-
structure. 
Pursuit 
[Modugno  and Myers 1994] 
File man-
agement 
Scripts automate a series of ma-
nipulations. 
Filter sets contain files and 
folders. 
QUICK 
[Douglas et al. 1990] 
UI design  Actions may be associated with 
objects (that are then cloned). 
Objects may have attributes and 
be cloned and/or aggregated. 
TEXAO 
[Texier  and Guittet 1999] 
CAD 
Formulas may drive values of 
attributes on cloneable objects. 
Instances of classes may pos-
sess attributes and sub-objects. 
Table 3. Behavioral and data abstractions in some end-user programming environments. 
28 
al. 2008]. This unplanned sharing also means that improvements to the originally copied 
or shared code do not propagate to the copies that need it.  This distinction between 
planned and unplanned reuse can demand different reuse technologies. For  example, 
many professional development tools that support copying, such as the “linked editing” 
technology described by Toomim et al. [2004], require users to plan their copying activi-
ties. 
3.3.4. Designing Reusable Code for End Users. One way to facilitate reuse by end us-
s-
ers is to choose the right abstractions for their problem domains. This means choosing the 
right concepts and choosing the right level of abstraction for such concepts. For example, 
the designers of the Alice 3D programming system [Dann et al. 2006] consciously de-
-
signed their APIs to provide abstractions that more closely matched peoples’ expectations 
about cameras, perspectives, and  object  movement. The  designers of  the Visual  Ba-
sic.NET APIs based their API designs on a thorough study of the common programming 
tasks of a variety of programmer populations [Green et al. 2006]. The Google Maps API 
is related in that the key to its success has been the relative ease with which users can 
annotate geographical images with custom data types. 
In other cases, choosing the right abstractions for a problem domain involves under-
standing the data used in the domain, rather than the behavior. For example, Topes [Scaf-
f-
fidi et al. 2008] is a framework for describing string data types unique to an organization, 
such as room numbers, purchase order IDs, and phone number extensions (see Figure 6). 
By supporting the design of these custom data types, end-user programmers can more 
easily process and validate information, as well as transform information between differ-
ent formats. This is a fundamental problem in many new domains of end-user program-
m-
ming, such as “mashup” design tools [Wong and Hong 2007] and RSS feed processors 
(e.g., http://pipes.yahoo.com). 
29 
Of course, as with any design, designing the right abstractions has tradeoffs. Special-
izing abstractions can result in a mismatch between the functionality of a reusable ab-
straction and the functionality needed by a programmer [Ye and Fischer 2005, Wieden-
beck 2005]. For example, many functional mismatches occur because specialized abstrac-
tions often have non-local effects on the state of a program [Biggerstaff and Richter 
1989]. In addition to functional mismatch, non-functional issues can cause abstractions 
not to mesh well with the new program [Ravichandran and Rothenberger 2003, Shaw 
1995]. End-user software engineering research is only beginning to consider this space of 
API and library design issues. 
3.4. Is My Program Working Correctly? —Verification and Testing 
There is a large range of ways to gain confidence about the correctness of a program, 
am, 
including through verification, testing, or a number of other approaches. The goals of 
of 
testing and verification techniques are universal: they enable people to have a more ob-
b-
jective and accurate level of confidence than they would if they were left unassisted. 
Where EUSE and professional SE differ is that end-user programmers’ priorities often 
lead to overconfidence in the correctness of their programs. 
Figure 6. The Toped++ pattern editor [Scaffidi et al. 2008], allowing the creation of string data types that sup-
p-
port recognition of matching strings and transformation between formats. Original figure obtained from authors. 
30 
Research on testing and verification in end-user programming has primarily focused 
on helping end users manage their overconfidence, and primarily for the spreadsheet 
paradigm
gm
3
. More recent work has broadened support for testing and verification to the 
he 
web and researchers are also beginning to generalize the spreadsheet-focused technolo-
o-
gies to other paradigms and domains. In this section, we discuss these various contribu-
-
tions and organize research by the different approaches to helping end-user programmers 
overcome overconfidence. 
3.4.1. Oracles and Overconfidence. A central issue for any type of verification is the 
decision about whether a particular program behavior or output is correct. The source of 
such knowledge is usually referred to as an oracle. Oracles might be people, making 
more or less formal decisions about the correctness of program behavior, or oracles can 
be explicitly documented definitions of the correct and intended behavior. 
People are typically imperfect oracles. Professional programmers are known to be 
overconfident [Leventhal et al. 1994, Teasley and Leventhal 1994, Lawrance et al. 2005], 
but such overconfidence subsides as they gain experience [Ko et al. 2007]. Some end-
user programmers, in comparison,  are notoriously overconfident: many studies about 
spreadsheets report that despite the high error rates in spreadsheets, spreadsheet develop-
ers are heedlessly confident about correctness [Panko 1998, Panko 2000, Hendry and 
Green 1994]. In one study, overconfidence about the correctness of spreadsheet cell val-
ues was associated with a high degree of overconfidence about the spreadsheets’ overall 
correctness [Wilcox 1997]. In fact, for spreadsheets, studies report that between 5% and 
23% of the value judgments made by end-user programmers are incorrect [Ruthruff et al. 
2005a, Ruthruff et al. 2005b, Phalgune et al. 2005].  In all of these studies, people were 
much more likely to judge an incorrect value to be right than a correct value to be wrong. 
These findings have implications for creators of error detection tools.  The first is that 
immediate feedback about the values a program computes, without feedback about cor-
r-
rectness, leads to significantly higher overconfidence [Rothermel et al. 2000, Krishna et 
al. 2001]. Second, because end users' negative judgments are more likely to be correct 
than positive judgments, a tool should “trust” negative judgments more.  One possible 
strategy for doing so is to implement a “robustness” feature that guards against a large 
3
One possible explanation for this bias is that Microsoft Excel, the most widely used spread-
sheet language, tends to produce output even in the presence of errors. This then leads to user over-
confidence in program correctness, which researchers have tried to remedy through better testing 
tools. Furthermore, much of the original research on end-user software engineering was inspired by 
Nardi‘s investigation of spreadsheet use in business contexts [1992].
Documents you may be interested
Documents you may be interested