how to upload pdf file in c# windows application : How to search text in pdf document software SDK dll winforms windows .net web forms pepm091-part631

5.1 RefiningaTabletoasstable
Itispossibletotransformatable(amapwithkeyoftypeAandvaluesoftype
B)intoasstable(alistoftuples)andvice-versaaslongasthereisaconstraint
imposingthatthereexistsaFDbetweentheelementsinthecolumnoftypeA
andthecolumnoftypeB:
AB
Table2sstable

(A ×B)
list2set◦compList⊆list2set◦listId
Sstable2table

Here, list2set transforms a list into a set, compList sees a list as a relation
and compose it with its inverse. listId is the list resulting from transforming the
id relation into a list. This definition of FD is based on the definition of FD
presented in [21]. From now on this invariant will be designated fd. The proof
of this data refinement can be found in [22].
The rule is implemented in Haskell as follows.
table2sstable ::Rule
table2sstable (a  b)
i
=return $View rep [a ×b]
inv
where
inv
=trySimplify (i ◦ Sstable2table ∧ fd)
rep = Rep{to = Table2sstable,from = Sstable2table}
where trySimplify is a rule that simplifies the invariant.
If the relational table has already an invariant, then it is composed with
the invariant of the new type concerning with the FD. The resulting invariant
is then simplified. This is just part of the rule’s implementation since another
function is necessary to encode the rule when the initial argument does not have
an associated invariant.
Let us use this rule to map the table with information about clients of our
running example.
∗ghcitable2sstable (clientNo  cName)
Just (View (Reptofrom) [clientNo ×cName]
fd
)
The result of this rule is a datatype modelling a spreadsheet that constains
the attribute of the database. The invariant fd guarantees that the functional
dependency isnow present in the datatype. Moreoever, the returned to and from
functions are the migration functions needed to map the data between the two
models.
5.2 Refining Tables with Foreign Keys on Primary Keys
Apair of tables where the primary key of the first table is a foreign key to the
primary key of the second table, can be refined to a pair of sstables using the
following law:
How to search text in pdf document - search text inside PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn how to search text in PDF document and obtain text content and location information
search pdf for text; text select tool pdf
How to search text in pdf document - VB.NET PDF Text Search Library: search text inside PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn How to Search Text in PDF Document and Obtain Text Content and Location Information in VB.NET application
searching pdf files for text; how to make a pdf file text searchable
((A  B) ×(C  D))
π
A
◦δ◦π
1
⊆π
C
◦δ◦π
2
Tables2sstable

((A × B)
fd
×(C ×D)
fd
)
π
A
◦list2set◦π
1
◦π
1
⊆π
C
◦list2set◦π
1
◦π
2
Sstables2tables

The invariant guarantees that exists a FK from the PK of the first table
to the PK of the second table. The π
A
projection has type π
A
:A → E and
π
C
:C → E. A must be a tuple of the form A
1
×...×E ×...×A
n
and C of the
form C
1
×... ×E ×...×C
n
.This allows that just part of the PK of each table
is used in the FK definition. The proof of this refinement corresponds to apply
twice the refinement presented in Section 5.1. The invariant must be updated
to work on the new type. The Haskell function table2sstable implements the
rule.
table2sstable ::Rule
table2sstable ((a  b) ×(c  d))
π
A
◦δ◦π
1
⊆π
C
◦δ◦π
2
=
return $ View rep ([a ×b]
fd
×[c ×d]
fd
)
inv
where
inv = π
A
◦list2set ◦π
1
◦π
1
⊆π
C
◦list2set ◦π
1
◦π
2
rep = Rep{to = Table2sstable × Table2sstable,
from = Sstable2table ×Sstable2table }
Aparticular instance of this refinement occurs when π
A
is the identity func-
tion. In this case all the attributes of the PK of the first table, are FKs to part
of the attributes of the PK of the second table. Another instance of this refine-
ment is when π
C
=id, that is, part of the attributes of the PK of the first table
reference all the attributes of the PK of the second table. Both cases are very
similar to the general one and they are not shown here. A final instance of this
rule presents π
A
andπ
C
has the identity functionmeaning that all the attributes
of the PK of the first table are FKs to all the attributes of the PK of the second
table. In this case the refinement changes as we show next.
((A  B) × (A  C))
δ◦π
1
⊆δ◦π
2
Tables2table

=
A (C × B?)
Table2tables

The values of the second table have a ?
4
because it can be the case that
some keys in the second table are not referenced in the first one. This happens
because it is not always true that all the keys have a foreign usage. The proof of
such an isomorphism is as follows.
4
This symbol means optional. it is also representable as A + 1. In Haskell it is
represented by the datatype Maybe x = Just x | Nothing.
C# Word - Search and Find Text in Word
C# Word - Search and Find Text in Word. Learn How to Search Text in PDF Document and Obtain Text Content and Location Information. Overview.
find and replace text in pdf; cannot select text in pdf file
C# PDF insert text Library: insert text into PDF content in C#.net
C#.NET PDF SDK - Insert Text to PDF Document in C#.NET. This C# coding example describes how to add a single text character to PDF document. // Open a document.
how to search pdf files for text; how to make a pdf document text searchable
A (C ×B?)
=
{
A?
=
1A
}
(1)
A (C ×(1  B))
=
{
A (D×(B C))
=((A  D) ×(A ×B  C))
π
1
◦δ◦π
2
⊆δ◦π
1
}
(2)
((A  C) × (A ×1  B))
π
1
◦δ◦π
2
⊆δ◦π
1
=
{
A
=
A×1
}
(3)
((A  C) × (A  B))
δ◦π
2
⊆δ◦π
1
Proofs of rules 1, 2, and 3 can be found in [9], [4], and [23]. A function in
Haskell was created to define this isomorphism.
tables2table :: Rule
tables2table ((a  b) × (a  c))
δ◦π
1
⊆δ◦π
2
=
return $ View rep (a  c × Maybe b)
where
rep = Rep{to = Tables2table,from = Table2tables}
Note that each of these rules has a dual one, that is, for each rule refining a
pair A×B there exists another one refining the pair B×A, with the appropriate
invariant.
5.3 Refining Tables with Foreign Keys on Non Primary Keys
In the previous section we have introduced refinement rules to manipulate tables
with FKs to PKs. In this section we present another set of rules to deal with FKs
in the non-key attributes. The diagram of the general rule is presented below.
((A  B) × (C  D))
π
B
◦ρ◦π
1
⊆π
C
◦δ◦π
2
Tables2sstables

((A ×B)
fd
×(C × D)
fd
)
π
B
◦list2set◦π
2
◦π
1
⊆π
C
◦list2set◦π
1
◦π
2
Sstables2tables

The proof of this refinement corresponds again to apply twice the refinement
presented in Section 5.1. The invariant must be updated to work on the new
type too. The function tables2sstables implements this refinement.
tables2sstables
((a  b) × (c  d))
π
B
◦ρ◦π
1
⊆π
C
◦δ◦π
2
=
return $ View rep ([a ×b]
fd
×[c ×d]
fd
)
π
B
◦list2set◦π
2
◦π
1
⊆π
C
◦list2set◦π
1
◦π
2
C# PowerPoint - Search and Find Text in PowerPoint
C# PowerPoint - Search and Find Text in PowerPoint. Learn How to Search Text in PDF Document and Obtain Text Content and Location Information. Overview.
how to select all text in pdf file; how to select text in pdf image
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Easy to search PDF text in whole PDF document. C# HTML5 PDF Viewer: View PDF Online. 13. Page Thumbnails. Navigate PDF document with thumbnails. 14. Text Search.
pdf find highlighted text; how to select text in a pdf
where
rep = Rep{to = Table2sstable × Table2sstable,
from = Sstable2table ×Sstable2table }
This refinement has three other particular cases. One where π
B
=id, another
where π
C
=id, and finally when π
B
C
=id. In these cases the refinement is
the same, only the invariant changes. The proof and implementation of this rule
are very similar to the general case and so not shown here.
Let us consider again our running example. In order to use this rule we
consider two FDs where all the PK of second table is referenced by part of the
non-key attributes of the first one.
∗ghcilet prop = propertyNo  pAddress ×rentPerDay ×ownerNo
∗ghcilet owner = ownerNo  oName
∗ghcimaps2tables (prop ×owner)
π
ownerNo
◦ρ◦π
1
⊆δ◦π
2
Just (View (Reptofrom)
(prop
×owner
)
π
ownerNo
◦list2set◦π
1
◦π
1
⊆list2set◦π
1
◦π
2
)
where
prop
=[propertyNo ×pAddress ×rentPerDay ×ownerNo]
owner
=[ownerNo ×oName]
In this case the two initial pairs are transformedinto two lists. The constraint
is updated to work with such structures.
5.4 Data Refinements as a Strategic Rewrite System
The individual refinement rules can be combined into a compound rules and full
transformation systems using the strategy combinators shown in Section 4.2. In
particular, we define a compound rule to map a RDB to a spreadsheet:
rdb2ss :: Rule
rdb2ss = simplify 
(many ((aux tables2sstables) (aux tables2sstables
))) 
(many (aux table2sstable))
where
aux r = ((once r)  simplify)  many ((once r)  simplify)
This function starts by simplifying the invariants. Then the tables2sstables rule
(defined in Section 5.2) is applied exhaustively (with aux) to transform tables
intosstables. After that the tables2sstables rule (Section 5.3) isapplied. In a final
step, the remaining maps are transformed using the table2sstable (Section 5.1)
rule. After each rule has been applied a simplification step is executed. This
strategy requires the simplification of the invariants because pattern matching
is performed not only on the type representations, but also on the invariants.
The simplify rule is defined as follows:
simplify ::Rule
simplify = many (prodsrdb mapsrdb others  myRules)  compr
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
All text content of target PDF document can be copied and pasted to .txt files by keeping original layout. C#.NET class source code
search text in pdf using java; pdf find and replace text
C# PDF delete text Library: delete, remove text from PDF file in
The following C# coding example illustrates how to perform PDF text deleting function in your .NET project, according to search option. // Open a document.
pdf find text; pdf text search tool
The functions prodsrdb,mapsrdb,others, andmyRules are functions that simplify
invariants. We include here the code of the first one. It simplifies products:
prod
def :: Rule
prod
def (Func (a ×b)
)(f × g) = success "Prod-Def" ((f ◦π
1
)(g ◦ π
2
))
prod
def
=fail "Cannot apply Prod-Def!"
6 The HaExcel Framework
HaExcel is a framework to manipulate, transform and query spreadsheets. We
provide an overview of the various parts of the framework and we demonstrate
its use by example.
6.1 The Framework
HaExcel is implemented in Haskell and consists of the following parts:
Library A generic/reusable library to map spreadsheets into relational database
models and back: This library contains an algebraic data type to model a
(generic) spreadsheet and functions to transform it into a relational model and
vice versa. Such functions implement the refinement rules introduced in Sec-
tion 5. The library includes two code generator functions: one that produces
the SQL code to create and populate the database, and a function that gen-
erates Excel/Gnumeric code to map the database back into a spreadsheet. A
MySQL database can also be created and manipulated using this library under
HaskellDB [7,15]. The API of HaExcel is included in Appendix A.
Front-ends A frontend to read spreadsheets in the Excel and Gnumeric for-
mats: The frontend reads spreadsheets in the portable XML documents using
the UMinho Haskell Libraries [1]. We reuse the spatial logic algorithms from the
UCheck project [3] to discover the tables stored in the spreadsheet. The first
row of each table is used as labels and the remaining elements are assumed to
be data.
Tools Two spreadsheet tools: A batch and a online tool that allow the users to
read, transform, refactor and query spreadsheets.
6.2 The House Renting Spreadsheet Revisited
In Section 2 we have informally presented the refactoring of the house renting
spreadsheet. In this section, we will use the HaExcel library functions to perform
such refactoring automatically.
The library function ss2rdb (see Appendix A) reads the Excel spreadsheet
from a file and produces the RDB schema and the migrated data. This function
performsthe following steps:First, it uses the function readSS to readthe spread-
sheet stored in the file received as argument. This function not only reads the
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Easy to search PDF text in whole PDF document. VB.NET HTML5 PDF Viewer: View PDF Online. 13. Page Thumbnails. Navigate PDF document with thumbnails. 14. Text Search
how to select text in pdf; search pdf files for text programmatically
VB.NET PDF replace text library: replace text in PDF content in vb
following coding example illustrates how to perform PDF text replacing function in your VB.NET project, according to search option. 'Open a document Dim doc As
can't select text in pdf file; how to search a pdf document for text
Excel file, but it also detects the tables in the spreadsheet (using UCheck func-
tions). Next, the rel2rdb function uses the already presented fun and synthesize
functions to compute the functional dependencies and construct the relational
database schema. The data refinement rules are used to map the spreadsheet
into a database model. The ss2rdb returns a pair containing the the database
schema and the migrated data, that conforms to the returned schema. The mi-
grated data is computed using the functions automatically derived during the
refinement. Next, we show the returned RDB schema obtained for the running
example.
(clientNo ×propertyNo  rentStart × rentFinish ×total rent × totalDays ×
clientNo  cName ×
(propertyNo  pAddress × rentPerDay ×ownerNo ×
ownerNo  oName)
inv1
)
inv2
where
inv1 = π
ownerNo
◦ρ ◦π
1
⊆δ ◦π
2
inv2 = π
clientNo
◦δ ◦π
1
⊆δ ◦ π
1
◦π
2
∧π
propertyNo
◦δ ◦ π
1
⊆δ ◦π
1
◦π
2
◦π
2
and, the migrated data.
{((cr76,pg4),(1/7/00,(8/31/01,(30100,602)))),
((cr75,pg16),(9/1/01,(9/1/02,(25550,365)))),
((cr56,pg4),(9/2/99,(6/10/00,(14100,282)))),
((cr56,pg36),(10/10/00,(12/1/01,(25550,417)))),
((cr56,pg16),(11/1/02,(8/10/03,(19740,282))))}
({(cr76,john),(cr56,aline)},
({(pg4,(6 Lawrence St .,(50,co40))),(pg16,(5 Novar Dr .,(70,co93))),
(pg36,(2 Manor Rd,(60,co93)))},
{(co40,tina),(co93,tony)}))
The returned RDB schema defines a 3NF database, consisting of four tables.
This corresponds exactly to the four tables in the spreadsheet of Figure 2. The
same happens with the data: it corresponds to the data stored in that spread-
sheet. Having computed the relational database tables and the migrated data,
we can now export it into SQL and back into refactored spreadsheet.
The SQL Backend: This backend generates SQLcode whichcreatesthe database
according to the derived RDB schema. This is basically a simple SQL create
instruction based on the RDB schema. Furthermore, it produces SQL code to
insert the migrated data in the database, and, again, this corresponds to a SQL
insert instruction with the migrated data as argument. Because some values
of the spreadsheet are defined through formulas, we generate also a SQL trigger
that modelsthe spreadsheet formulas which are used to update the database and
guarantee its integrity. Next, we present the trigger induced by the two formulas
of our running example:
create trigger ssformulas before insert on tbl
for each row begin
set
new . totalDays = new . rentFinish −new . rentStart;
set
new . total
rent = new . rentPerDay ∗new . totalDays;
end;
The SQL code to create the database and insert the migrated data can be
obtained from the HaExcel webpage. We omit them here.
The Spreadsheet Backend: It generates the spreadsheet in the XML-based Ex-
cel/Gnumeric format. The data refinements define bidirectional transformations,
so we can map the optimized relational database back into a spreadsheet. Thus,
thisbackendimplements a spreadsheet refactoring tool. Figure 2 shows the result
of using this backend for the house renting system. Because, the spreadsheet for-
mulas are stored inthe database via triggers, the refactoredspreadsheet contains
such formulas too.
7 Related Work
Frost et al [14] describe a method of providing a spreadsheet-like interface to
arelational database. The method starts from meta-data about the data orga-
nization in the spreadsheet. Using this meta-data a bidirectional connection is
established between the spreadsheet and the database. No intermediate storage
or transformation is performed on the data, and the database schema is a direct
reflection of the spreadsheet organization captured by the metadata. No specific
method is given for providing the required meta-data in an automated fashion.
By contrast, our approach includesautomated discovery of spreadsheet organiza-
tion, derivation of a normalized database schema, and calculational construction
of the bi-directional connection between database and spreadsheet, which may
include complex transformations of the data that is exchanged.
Pierce et al [6,13] have addressed the view-update problem for databases with
combinators for bi-directional programming, called lenses. A database view con-
structed by composition of lenses allows updates at the view level to be pushed
back to the database level. Lenses are similar, but fundamentally different from
data refinements (a formal comparison is given by Oliveira [23]). Lenses can
be used to fit a flattened, spreadsheet-like view onto a normalized relational
database. Though our approach starts from a spreadsheet and derives a rela-
tional database, part of our solution involves the calculation of bi-directional
conversion functions, starting from the database schema and working back to
the initial spreadsheet. It would be interesting to investigate whether lenses can
be calculated similarly.
The 2LTproject [32] usestwo-level strategic term rewriting for coupled trans-
formation of data schemas, instances [9], queries [10], and constraints [4], in par-
ticular, hierarchical-relational data mappings. We adopted the same techniques
and demonstrated their application to transformation from non-structured data
(spreadsheets) to relational databases. We added new transformation rules and
strategieswithcorrespondingproofs.We integratedthe rewritingmachinery with
algorithms for detection of tables and functional dependencies and generation of
relational schemas.
Erwig et al have applied to spreadsheets various software engineering and
programming language principles, including type inference [3], debugging [2],
and object-oriented design [12]. In particular, the UCheck system [3] detects
errors in spreadsheets through automatic detection of headers and (numeric)
unit information. We have adopted some of the spatial logic algorithms from
UCheck in order to detect table boundaries.
8 Conclusions
In this paper, we have explored the relation between spreadsheets and relational
databases. In particular, we have made the following contributions.
1. We have extended the 2LT framework for two-level transformations with
constraint-aware
2. conversion rules between relational and tabular data structures. The correct-
ness of these rules is supported with proofs.
3. We have shown how these rules can be combined into a strategic rewrite
4. system that transforms a relational schema into a tabular schema and on
the fly derives conversion functions between these schemas.
5. We have combined this rewrite system with methods for discovering tables
in spreadsheets, deriving functional dependencies from the data contained in
them, and deriving relational schemas from these functional dependencies.
6. To these algorithmic components, we have connected importers and ex-
porters for SQL and spreadsheet formats.
7. We have shown how the resulting system canbe employed to convert spread-
sheets to relational databases and back. This allows refactoring of spread-
sheets to reduce data redundancy, migration of spreadsheet applications to
database applications, and advanced querying of spreadsheets with SQL
queries.
Notwithstanding these contributions, our approach presents a number of limita-
tionsthat we hope to remove in future. For example, we are currently supporting
only set of commonly used formulas, which remains to be enlarged to a wider
range.
More importantly, the algorithm for inferring functional dependencies needs
improvement. This algorithm does not work well for small sets of data and is
sensitive to “accidental” patterns in the data. Some well-chosen heuristics and
limited user interaction could alleviate this problem.
In the two-level rewrite system, syntactic matching is performed on repre-
sentations of constraints. Such syntactic matching could be generalized to verifi-
cation of logical implication of the actual constraint and the required constraint.
With respect to formulas and queries, we are not yet exploiting some inter-
esting opportunities. For example, a formula or query expressed in terms of the
source spreadsheet may be composed with the backward conversion function to
obtain a query on the target database or refactored spreadsheet. Suchmigrations
of queries have been explored in [10].
Finally, we are currently ignoring the possibility of having repeated rows in
the source spreadsheet. Also the order of rows is not taken into account. Thus,
we are effectively treating spreadsheet tables as sets of rows rather than bags or
lists of rows. The data refinement theory that underpins our approach can be
exploited to support these alternative perspectives where order and repetition
are considered relevant.
Availability The HaExcel library and tools are available from the homepage of
the first author.
References
1. UMinho
Haskell
Software
Libraries
and
Tools
-
http://wiki.di.uminho.pt/twiki/bin/view/research/pure/puresoftware.
2. R. Abraham and M. Erwig. GoalDebug: A spreadsheet debugger for end users. In
29th International Conference on Software Engineering (ICSE 2007), pages 251–
260. IEEE Computer Society, 2007.
3. R. Abraham and M. Erwig. UCheck: A spreadsheet type checker for end users. J.
Vis. Lang. Comput., 18(1):71–95, 2007.
4. T.L. Alves, P.F. Silva, and J. Visser. Constraint-aware Schema Transformation.
In The Ninth International Workshop on Rule-Based Programming, 2008.
5. C.Beeri, R.Fagin,and J.H. Howard. A complete axiomatization for functional and
multivalued dependencies in database relations. In Proc. of the ACM SIGMOD
Int. Conf. on Management of Data, pages 47–61, 1977.
6. A. Bohannon, J.A. Vaughan, and B.C. Pierce. Relational lenses: A language for
updateable views. In Principles of Database Systems (PODS), 2006.
7. B. Bringert, A. H¨ockersten, C. Andersson, M. Andersson, M. Bergman,
V. Blomqvist, and T. Martin. Student paper: HaskellDB improved. In Haskell
’04: Proceedings of the 2004 ACM SIGPLAN workshop on Haskell, pages 108–115,
New York, NY, USA, 2004. ACM.
8. T. Connolly and C. Begg. Database Systems, A Practical Approach to Design,
Implementation, and Management. Addison-Wesley, 3 edition, 2002.
9. A. Cunha, J.N. Oliveira, and J. Visser. Type-safe Two-level Data Transformation.
In J. Misra et al., editors, Proc. Formal Methods, 14th Int. Symp. Formal Methods
Europe, volume 4085 of LNCS, pages 284–299. Springer, 2006.
10. A. Cunha and J. Visser. Strongly typed rewriting for coupled software transfor-
mation. ENTCS, 174(1):17–34, 2007. Proc. 7th Int. Workshop on Rule-Based
Programming (RULE 2006).
11. C. J. Date. An Introduction to Database Systems, 6th Edition. Addison-Wesley,
1995.
12. G. Engels and M. Erwig. ClassSheets: automatic generation of spreadsheet appli-
cations fromobject-oriented specifications. In David F.Redmiles, Thomas Ellman,
and Andrea Zisman, editors, 20th IEEE/ACM International Conference on Auto-
mated Software Engineering (ASE 2005), November 7-11, 2005, Long Beach, CA,
USA, pages 124–133. ACM, 2005.
13. J. Nathan Foster, Michael B. Greenwald, Jonathan T. Moore, Benjamin C. Pierce,
and Alan Schmitt. Combinators for bidirectional tree transformations: A linguis-
tic approach to the view-update problem. ACM Transactions on Programming
Languages and Systems, 29(3):17, May 2007.
14. B.H. Frost and S.D. Stanton. Spreadsheet-based relational database interface,
January 2008. US Patent 20080016041.
15. D. Leijen and E. Meijer. Domain specific embedded compilers. In 2nd USENIX
Conference on Domain Specific Languages (DSL’99), pages 109–122, Austin,
Texas, October 1999.
16. D. Maier. The Theory of Relational Databases. Computer Science Press, 1983.
17. C.Morgan and P.H.B. Gardiner. Data refinementbycalculation. Acta Informatica,
27:481–503, 1990.
18. N. Novelli and R. Cicchetti. Fun: An efficient algorithm for mining functional and
embedded dependencies. In ICDT ’01: Proceedings of the 8th International Con-
ference on Database Theory, pages 189–203, London, UK, 2001. Springer-Verlag.
19. J.N. Oliveira. A reification calculus for model-oriented software specification. For-
mal Asp. Comput., 2(1):1–23, 1990.
20. J.N. Oliveira. ”Fractal” Types: an Attempt to Generalize Hash Table Calculation.
In Workshop on Generic Programming (WGP’98), Marstrand, Sweden, June 1998.
21. J.N. Oliveira. Functional dependency theory made ’simpler’. Technical Report
PURe-05.01.01, DI-Research, January 2005.
22. J.N. Oliveira. Pointfree foundations for (generic) lossless decomposition. 2007.
Submitted.
23. J.N. Oliveira. Transforming data by calculation. In R. L¨ammel, J. Saraiva, and
J. Visser, editors, Generative and Transformational Techniques in Software En-
gineering II, International Summer School, GTTSE 2007, Braga, Portugal, July
2-7, 2007. Revised Papers, volume 5235 of Lecture Notes in Computer Science.
Springer, To appear, 2008.
24. R.R. Panko. Spreadsheet errors: What we know. what we think we can do. Pro-
ceedings of the Spreadsheet Risk Symposium, European Spreadsheet Risks Interest
Group (EuSpRIG), July 2000.
25. S. Peyton Jones. Haskell 98: Language and libraries. J. Funct. Program., 13(1):1–
255, 2003.
26. S. Peyton Jones, G. Washburn, and S. Weirich. Wobbly types: type inference
for generalised algebraic data types. Technical Report MS-CIS-05-26, Univ. of
Pennsylvania, July 2004.
27. K. Rajalingham, D. Chadwick, B. Knight, and D. Edwards. Quality control in
spreadsheets: A software engineering-based approach to spreadsheet development.
In HICSS ’00: Proc. 33rd Hawaii International Conference on System Sciences-
Volume 4, page 4006, Washington, DC, USA, 2000. IEEE Computer Society.
28. C. Scaffidi, M. Shaw, and B. Myers. Estimating the numbers of end users and end
user programmers. Visual Languages and Human-Centric Computing, 2005 IEEE
Symposium on, pages 207–214, 20-24 Sept. 2005.
29. T. SH Teo and M. Tan. Quantitative and qualitative errors in spreadsheet devel-
opment. Proc. Thirtieth Hawaii Int. Conf. on System Sciences, 3:149–156, 1997.
30. M. Tukiainen. Uncovering effects of programming paradigms:Errors in two spread-
sheet systems. 12th Workshop of the Psychology of Programming Interest Group
(PPIG), pages 247–266, April 2000.
31. J.D. Ullman. Principles of Database and Knowledge-Base Systems, Volume I.
Computer Science Press, 1988.
Documents you may be interested
Documents you may be interested