Jeremy G. Siek

Bio: Jeremy G. Siek is an academic researcher from Indiana University. The author has contributed to research in topics: Gradual typing & Generic programming. The author has an hindex of 31, co-authored 128 publications receiving 4213 citations. Previous affiliations of Jeremy G. Siek include University of Colorado Boulder & University of Colorado Denver.

The Boost graph library : user guide and reference manual

Abstract: Foreword. Preface. I User Guide. 1. Introduction. Some Graph Terminology. Graph Concepts. Vertex and Edge Descriptors. Property Maps. Graph Traversa. Graph Construction and Modification Algorithm Visitors. Graph Classes and Adaptors. Graph Classes. Graph Adaptors. Generic Graph Algorithms. The Topological Sort Generic Algorithm. The Depth-First Search Generic Algorithm. 2.Generic Programming in C++. Introduction. Polymorphism in Object-Oriented Programming. Polymorphism in Generic Programming. Comparison of GP and OOP. Generic Programming and the STL. Concepts and Models. Sets of Requirements. Example: InputIterator. Associated Types and Traits Classes. Associated Types Needed in Function Template. Typedefs Nested in Classes. Definition of a Traits Class. Partial Specialization. Tag Dispatching. Concept Checking. Concept-Checking Classes. Concept Archetypes. The Boost Namespace. Classes. Koenig Lookup. Named Function Parameters. 3. A BGL Tutorial. File Dependencies. Graph Setup. Compilation Order. Topological Sort via DFS. Marking Vertices Using External Properties. Accessing Adjacent Vertices. Traversing All the Vertices. Cyclic Dependencies. Toward a Generic DFS: Visitors. Graph Setup: Internal Properties. Compilation Time. A Generic Topological Sort and DFS. Parallel Compilation Time. Summary. 4. Basic Graph Algorithms. Breadth-First Search. Definitions. Six Degrees of Kevin Bacon. Depth-First Search. Definitions. Finding Loops in Program-Control-Flow Graphs. 5. Shortest-Paths Problems. Definitions. Internet Routing. Bellman-Ford and Distance Vector Routing. Dijkstra and Link-State Routing. 6. Minimum-Spanning-Tree Problem. Definitions. Telephone Network Planning. Kruskal's Algorithm. Prim's Algorithm. 7. Connected Components. Definitions. Connected Components and Internet Connectivity. Strongly Connected Components and Web Page Links. 8. Maximum Flow. Definitions. Edge Connectivity. 9. Implicit Graphs: A Knight's Tour. Knight's Jumps as a Graph. Backtracking Graph Search. Warnsdorff's Heuristic. 10. Interfacing with Other Graph Libraries. Using BGL Topological Sort with a LEDA Graph. Using BGL Topological Sort with a SGB Graph. Implementing Graph Adaptors. 11. Performance Guidelines. Graph Class Comparisons. The Results and Discussion. Conclusion. II Reference Manual. 12. BGL Concepts. Graph Traversal Concepts. Undirected Graphs. Graph. IncidenceGraph. BidirectionalGraph. AdjacencyGraph. VertexListGraph. EdgeListGraph. AdjacencyMatrix. Graph Modification Concepts. VertexMutableGraph. EdgeMutableGraph. MutableIncidenceGraph. MutableBidirectionalGraph. MutableEdgeListGraph. PropertyGraph. VertexMutablePropertyGraph. EdgeMutablePropertyGraph. Visitor Concepts. BFSVisitor. DFSVisitor. DijkstraVisitor. BellmanFordVisitor. 13. BGL Algorithms. Overview. Basic Algorithms. breadth_first_search. breadth_first_visit. depth_first_search. depth_first_visit. topological_sort. Shortest-Path Algorithms. dijkstra_shortest_paths. bellman_ford_shortest_paths. johnson_all_pairs_shortest_paths. Minimum-Spanning-Tree Algorithms. kruskal_minimum_spanning_tree. prim_minimum_spanning_tree. Static Connected Components. connected_components. strong_components. Incremental Connected Components. initialize_incremental_components. incremental_components. same_component. component_index. Maximum-Flow Algorithms. edmunds_karp_max_flow. push_relabel_max_flow. 14. BGL Classes. Graph Classes. adjacency_list. adjacency_matrix. Auxiliary Classes. graph_traits. adjacency_list_traits. adjacency_matrix_traits. property_map. property. Graph Adaptors. edge_list. reverse_graph. filtered_graph. SGB GraphPointer. LEDA GRAPH . std::vector . 15. Property Map Library. Property Map Concepts. ReadablePropertyMap. WritablePropertyMap. ReadWritePropertyMap. LvaluePropertyMap. Property Map Classes. property_traits. iterator_property_map. Property Tags. Creating Your Own Property Maps. Property Maps for Stanford GraphBase. A Property Map Implemented with std::map. 16 Auxiliary Concepts, Classes, and Functions. Buffer. ColorValue. MultiPassInputIterator. Monoid. mutable queue. Disjoint Sets. disjoint_sets. find_with_path_halving. find_with_full_path_compression. tie. graph_property_iter_range. Bibliography. Index. 0201729148T12172001

Gradual typing for objects

Abstract: Static and dynamic type systems have well-known strengths and weaknesses. In previous work we developed a gradual type system for a functional calculus named Λ→?. Gradual typing provides the benefits of both static and dynamic checking in a single language by allowing the programmer to control whether a portion of the program is type checked at compile-time or run-time by adding or removing type annotations on variables. Several object-oriented scripting languages are preparing to add static checking. To support that work this paper develops Ob

Gradual Typing for Functional Languages

Abstract: Static and dynamic type systems have well-known strengths and weaknesses, and each is better suited for different programming tasks. There have been many efforts to integrate static and dynamic typing and thereby combine the benefits of both typing disciplines in the same language. The flexibility of static typing can be improved by adding a type Dynamic and a typecase form. The safety and performance of dynamic typing can be improved by adding optional type annotations or by performing type inference (as in soft typing). However, there has been little formal work on type systems that allow a programmer-controlled migration between dynamic and static typing. Thatte proposed Quasi-Static Typing, but it does not statically catch all type errors in completely annotated programs. Anderson and Drossopoulou defined a nominal type system for an object-oriented language with optional type annotations. However, developing a sound, gradual type system for functional languages with structural types is an open problem. In this paper we present a solution based on the intuition that the structure of a type may be partially known/unknown at compiletime and the job of the type system is to catch incompatibilities between the known parts of types. We define the static and dynamic semantics of a -calculus with optional type annotations and we prove that its type system is sound with respect to the simply-typed -calculus for fully-annotated terms. We prove that this calculus is type safe and that the cost of dynamism is “pay-as-you-go”.

Concepts: linguistic support for generic programming in C++

Abstract: Generic programming has emerged as an important technique for the development of highly reusable and efficient software libraries. In C++, generic programming is enabled by the flexibility of templates, the C++ type parametrization mechanism. However, the power of templates comes with a price: generic (template) libraries can be more difficult to use and develop than non-template libraries and their misuse results in notoriously confusing error messages. As currently defined in C++98, templates are unconstrained, and type-checking of templates is performed late in the compilation process, i.e., after the use of a template has been combined with its definition. To improve the support for generic programming in C++, we introduce concepts to express the syntactic and semantic behavior of types and to constrain the type parameters in a C++ template. Using concepts, type-checking of template definitions is separated from their uses, thereby making templates easier to use and easier to compile. These improvements are achieved without limiting the flexibility of templates or decreasing their performance - in fact their expressive power is increased. This paper describes the language extensions supporting concepts, their use in the expression of the C++ Standard Template Library, and their implementation in the ConceptGCC compiler. Concepts are candidates for inclusion in the upcoming revision of the ISO C++ standard, C++0x.

A comparative study of language support for generic programming

Abstract: Many modern programming languages support basic generic programming, sufficient to implement type-safe polymorphic containers. Some languages have moved beyond this basic support to a broader, more powerful interpretation of generic programming, and their extensions have proven valuable in practice. This paper reports on a comprehensive comparison of generics in six programming languages: C++, Standard ML, Haskell, Eiffel, Java (with its proposed generics extension), and Generic C. By implementing a substantial example in each of these languages, we identify eight language features that support this broader view of generic programming. We find these features are necessary to avoid awkward designs, poor maintainability, unnecessary run-time checks, and painfully verbose code. As languages increasingly support generics, it is important that language designers understand the features necessary to provide powerful generics and that their absence causes serious difficulties for programmers.

Bioconductor: open software development for computational biology and bioinformatics

Abstract: The Bioconductor project is an initiative for the collaborative creation of extensible software for computational biology and bioinformatics. The goals of the project include: fostering collaborative development and widespread use of innovative software, reducing barriers to entry into interdisciplinary scientific research, and promoting the achievement of remote reproducibility of research results. We describe details of our aims and methods, identify current challenges, compare Bioconductor to other open bioinformatics projects, and provide working examples.

Pregel: a system for large-scale graph processing

Abstract: Many practical computing problems concern large graphs. Standard examples include the Web graph and various social networks. The scale of these graphs - in some cases billions of vertices, trillions of edges - poses challenges to their efficient processing. In this paper we present a computational model suitable for this task. Programs are expressed as a sequence of iterations, in each of which a vertex can receive messages sent in the previous iteration, send messages to other vertices, and modify its own state and that of its outgoing edges or mutate graph topology. This vertex-centric approach is flexible enough to express a broad set of algorithms. The model has been designed for efficient, scalable and fault-tolerant implementation on clusters of thousands of commodity computers, and its implied synchronicity makes reasoning about programs easier. Distribution-related details are hidden behind an abstract API. The result is a framework for processing large graphs that is expressive and easy to program.

An overview of AspectJ

Abstract: Aspect] is a simple and practical aspect-oriented extension to Java With just a few new constructs, AspectJ provides support for modular implementation of a range of crosscutting concerns. In AspectJ's dynamic join point model, join points are well-defined points in the execution of the program; pointcuts are collections of join points; advice are special method-like constructs that can be attached to pointcuts; and aspects are modular units of crosscutting implementation, comprising pointcuts, advice, and ordinary Java member declarations. AspectJ code is compiled into standard Java bytecode. Simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes. Several examples show that AspectJ is powerful, and that programs written using it are easy to understand.

Mash: fast genome and metagenome distance estimation using MinHash.

Abstract: Mash extends the MinHash dimensionality-reduction technique to include a pairwise mutation distance and P value significance test, enabling the efficient clustering and search of massive sequence collections. Mash reduces large sequences and sequence sets to small, representative sketches, from which global mutation distances can be rapidly estimated. We demonstrate several use cases, including the clustering of all 54,118 NCBI RefSeq genomes in 33 CPU h; real-time database search using assembled or unassembled Illumina, Pacific Biosciences, and Oxford Nanopore data; and the scalable clustering of hundreds of metagenomic samples by composition. Mash is freely released under a BSD license ( https://github.com/marbl/mash ).