CS 1181-01: Computer Science II

This is the second course in a two-semester sequence introducing fundamental concepts and techniques for computer science and engineering. The course focuses on problem analysis, advanced programming concepts using JAVA and fundamental data structures. Students learn to analyze problems and evaluate potential solutions with respect to choice of data structures and computational efficiency. Student are exposed to the underlying implementation of basic data structures available in JAVA libraries and develop the skilled needs to extend existing data structures and design new data structures to solve increasingly complex problems. This is an integrated writing course

Two-Language, Two-Paradigm Introductory Computing Curriculum Model and its Implementation

This paper analyzes difficulties with the introduction of object-oriented concepts in introductory computing education and then proposes a two-language, two-paradigm curriculum model that alleviates such difficulties. Our two-language, two-paradigm curriculum model begins with teaching imperative programming using Python programming language, continues with teaching object-oriented computing using Java, and concludes with teaching object-oriented data structures with Java

Probabilistic Graphical Models on Multi-Core CPUs using Java 8

In this paper, we discuss software design issues related to the development of parallel computational intelligence algorithms on multi-core CPUs, using the new Java 8 functional programming features. In particular, we focus on probabilistic graphical models (PGMs) and present the parallelisation of a collection of algorithms that deal with inference and learning of PGMs from data. Namely, maximum likelihood estimation, importance sampling, and greedy search for solving combinatorial optimisation problems. Through these concrete examples, we tackle the problem of defining efficient data structures for PGMs and parallel processing of same-size batches of data sets using Java 8 features. We also provide straightforward techniques to code parallel algorithms that seamlessly exploit multi-core processors. The experimental analysis, carried out using our open source AMIDST (Analysis of MassIve Data STreams) Java toolbox, shows the merits of the proposed solutions.Comment: Pre-print version of the paper presented in the special issue on Computational Intelligence Software at IEEE Computational Intelligence Magazine journa

TAIL: Data Structures Tutorial Site

Any intermediate computer programmer will learn data structures. A data structure stores and organizes in-formation into useful groups in order for a computer program to run as efficiently as possible. Data structures become extremely important when managing large amounts of data, whether it be as simple as managing statistics for a basketball team, or as critical as accounts for online banking. The current way to learn data structures is through classes and online Java applets. In classes, most professors teach by drawing the data structure and editing the information on a board. Data structure tutorial websites mimic this visual way of teaching. No one, single site includes all types of data structures, which can be confusing and inconvenient for programmers. Current websites that teach data structures use Java applets which are obsolete, insecure, and run slowly. Most popular browsers disable Java by default because of these concerns. In order to use Java applets, users first find a site that has the proper data structure. Then, users must enable Java on the page in order to run the applet. When Java is disabled, browsers open a pop-up window informing users of Javas security risks and asking them if they would like to enable Java. Most users are discouraged by pop-ups because they are either unfamiliar with the warning or are concerned with security risks and will navigate away from the page. Finally, because each website is different, a user must adapt to the interface of that particular applet. We will have built a website that provides users with one, single place to find all the data structures they need. Our website includes most of the common data structures and allows users to easily create their own if they are not included. We have developed a pseudocode language, and accompanying compiler, that allows users without advanced web programming backgrounds to create their own data structures. Users describe their data structures in a high level, pseudocode language which is then be translated into code appropriate for the web. Users are able to create data structures in our language and the compiler handles the programming necessary to display that data structure visually. Our site makes use of modern web technologies, such as JavaScript and HTML5, to avoid the downfalls associated with Java applets. The website runs quickly and efficiently on all major Internet browsers to provide a hassle-free and hands-on tutorial for programmers wishing to learn data structures

Data Structures Lecture Notes (Student Version)

Lecture notes for a data-structures course in computer science with examples in Java. Students in this course should have already taken an intro-programming course in an object-oriented language and have a basic grasp of Java. These are not designed to accompany any specific textbook

Effective Strategic Programming for Java Developers

International audienceIn object programming languages, the Visitor design pattern allows separation of algorithms and data-structures. When applying this pattern to tree-like structures, programmers are always confronted with the difficulty of making their code evolve. One reason is that the code implementing the algorithm is interwound with the code implementing the traversal inside the Visitor. When implementing algorithms such as data analyses or transformations, encoding the traversal directly into the algorithm turns out to be cumbersome as this type of algorithm only focuses on a small part of the data-structure model (e.g., program optimization). Unfortunately, typed programming languages like Java do not offer simple solutions for expressing generic traversals. Rewrite-based languages like ELAN or Stratego have introduced the notion of strategies to express both generic traversal and rule application control in a declarative way. Starting from this approach, our goal was to make the notion of strategic programming available in a widely used language such as Java and thus to offer generic traversals in typed Java structures. In this paper, we present the strategy language SL that provides programming support for strategies in Java

Concrete Syntax with Black Box Parsers

Context: Meta programming consists for a large part of matching, analyzing, and transforming syntax trees. Many meta programming systems process abstract syntax trees, but this requires intimate knowledge of the structure of the data type describing the abstract syntax. As a result, meta programming is error-prone, and meta programs are not resilient to evolution of the structure of such ASTs, requiring invasive, fault-prone change to these programs. Inquiry: Concrete syntax patterns alleviate this problem by allowing the meta programmer to match and create syntax trees using the actual syntax of the object language. Systems supporting concrete syntax patterns, however, require a concrete grammar of the object language in their own formalism. Creating such grammars is a costly and error-prone process, especially for realistic languages such as Java and C++. Approach: In this paper we present Concretely, a technique to extend meta programming systems with pluggable concrete syntax patterns, based on external, black box parsers. We illustrate Concretely in the context of Rascal, an open-source meta programming system and language workbench, and show how to reuse existing parsers for Java, JavaScript, and C++. Furthermore, we propose Tympanic, a DSL to declaratively map external AST structures to Rascal's internal data structures. Tympanic allows implementors of Concretely to solve the impedance mismatch between object-oriented class hierarchies in Java and Rascal's algebraic data types. Both the algebraic data type and AST marshalling code is automatically generated. Knowledge: The conceptual architecture of Concretely and Tympanic supports the reuse of pre-existing, external parsers, and their AST representation in meta programming systems that feature concrete syntax patterns for matching and constructing syntax trees. As such this opens up concrete syntax pattern matching for a host of realistic languages for which writing a grammar from scratch is time consuming and error-prone, but for which industry-strength parsers exist in the wild. Grounding: We evaluate Concretely in terms of source lines of code (SLOC), relative to the size of the AST data type and marshalling code. We show that for real programming languages such as C++ and Java, adding support for concrete syntax patterns takes an effort only in the order of dozens of SLOC. Similarly, we evaluate Tympanic in terms of SLOC, showing an order of magnitude of reduction in SLOC compared to manual implementation of the AST data types and marshalling code. Importance: Meta programming has applications in reverse engineering, reengineering, source code analysis, static analysis, software renovation, domain-specific language engineering, and many others. Processing of syntax trees is central to all of these tasks. Concrete syntax patterns improve the practice of constructing meta programs. The combination of Concretely and Tympanic has the potential to make concrete syntax patterns available with very little effort, thereby improving and promoting the application of meta programming in the general software engineering context

Exploring C++

This book is intended for use by C programmers who want to learn C++ . . . fast. It may also be helpful for Java programmers learning C++ . It assumes that the reader knows basic programming including types, control structures, functions, arrays, pointers, and simple data structures. The material should help you develop a deep understanding of clean program design and the features that make C++ a powerful and flexible language.https://digitalcommons.newhaven.edu/electricalcomputerengineering-books/1001/thumbnail.jp

Towards Type-Based Optimizations in Distributed Applications Using ABS and JAVA 8

In this paper we present an API to support modeling applications with Actors based on the paradigm of the Abstract Behavioural Specification (ABS) language. With the introduction of JAVA 8, we expose this API through a JAVA library to allow for a high-level actor-based methodology for programming distributed systems which supports the programming to interfaces discipline. We validate this solution through a case study where we obtain significant performance improvements as well as illustrating the ease with which simple high and low-level optimizations can be obtained by examining topologies and communication within an application. Using this API we show it is much easier to observe drawbacks of shared data-structures and communications methods in the design phase of a distributed application and apply the necessary corrections in order to obtain better results