Online learning is useful for expanding educational offerings. This is crucial for institutions with limited space and courses with high demand. Universities still need to be mindful about the quality of their online offerings, and ensure that it meets higher education standards. In this work we present a retrospective comparison between concurrent offerings (one online and one in classroom) of a discrete math course. The online course was carefully designed to be as challenging as the classroom one. We note the key takeaways from the experience.

Matrix multiply is ubiquitous in scientific computing. Considerable effort has been spent on improving its performance. Once methods that make efficient use of the processor have been exhausted, methods that use less operations than the canonical matrix multiply must be explored. Combining the two methods yields a hybrid matrix multiply algorithm. Hybrid matrix multiply algorithms tend to be less accurate than the canonical matrix multiply implementation, leaving room for improvement. There are well-known techniques for improving accuracy, but they tend to be slow and it is not immediately obvious how best to apply them to hybrid algorithms without lowering performance. Previous attempts have focused on the bottom of the hybrid matrix multiply algorithm, modifying the high-performance matrix multiply implementation. In contrast, the top-down approach presented here does not require the modification of the high-performance matrix multiply implementation at the bottom, nor does it require modification of the fast asymptotic matrix multiply algorithm at the top. The three-level hybrid algorithm presented here not only has up to 10% better performance than the fastest high-performance matrix multiply, but is also more accurate.

Many network activities can benefit from accurate traffic classification and categorization, such as QOS control, network security monitoring, and traffic accounting. In this paper, a new approach based on feed-forward neural network is proposed for accurate traffic classification, which eliminates the disadvantages of port-based or payload-based classification methods. Extensive experimentation and comparison have been carried out to explore this new approach; it has been found out that, combined with a fast correlation-based feature selection filter, better performance and more accurate classification results can be obtained using neural network method compared to other techniques. For its good performance and elimination of accessing the contents of the packets, the proposed technique is expected to have a promising application prospect in internet traffic classification.

We compare four paradigms that have recently been the subject of recent research: mobile agents, distributed shared memory (DSM), coordination paradigms, and self-migrating computations. We place these paradigms in a common framework and demonstrate that self-migrating computations subsume the other three paradigms in terms of their capabilities to organize and coordinate computation, and map the concurrent activities onto a multicomputer architecture. We then demonstrate the advantages of self-migration in terms of algorithmic integrity, performance, the ability to generate parallel programs, and the ability to support incremental parallelization. Keywords—Coordination, DSM, mobile agents, parallel and distributed computing, self-migrating computations.

We compare four paradigms that have recently been the subject of considerable attention: mobile agents, distributed shared memory (DSM), coordination paradigms, and self-migrating threads. We place these paradigms in a common framework consisting of three layers--the computational model, its implementation on a physical architecture, and the interface to the system's environment--to demonstrate that self-migrating threads subsume the other three paradigms in terms of their capabilities to organize and coordinate computation, map the concurrent activities onto a multicomputer architecture, and provide an interface for interaction with their environments on the underlying host computers.

In systems aiming at high-speed distributed applications, load balancing plays an essential role. If a process can be easily broken down into several sub-parts, it is possible to do the load balancing transparently to the user application. This is possible if processes consist of multiple threads, distributed objects, or logical nodes. Then some of these parts could be transparently migrated from overloaded process to the underloaded ones by the runtime system. During component migration, the communication links among the system components must be preserved. To allow efficient load balancing, the migration should have minimal effect on the performance of the non-migrating components of the system. This paper presents a migration mechanism for preserving communication links between system components. The presented mechanism uses minimal knowledge of the system topology and requires only the component being moved to stop computing while in transit, which makes this algorithm applicable to large distributed computations.

With self-migrating computations, the main challenge is the extraction and subsequent restoration of the computation’s state during migration. This is very difficult when the navigational statement may be placed anywhere in the code and hence many systems place the burden of state capture on the application programmer. We describe an intermediate approach, where the use of navigational statements is restricted to the top level of the self-migrating computation. This permits an efficient implementation of a fully transparent state capture and restoration. We demonstrate that this approach is applicable not only to interpreted mobile code but also to compiled self-migrating computations executing entirely in native mode.

Mobile agents have an underserved reputation for poor performance. With optimizations and improvements at the compiler, middleware, and hardware levels, navigational programming can be an efficient, high performance method for distributed computing. Improvements at all three of these levels were explored in this research. At the compiler level, Diaktoros improves navigational programming in two ways. First, each agent is allowed direct access to both its own internal variables and those in shared memory. This improves performance by eliminating redirection through a table or other structure. Second, migration is implemented as a fundamental operation. This allows the compiler to treat mobility almost independently from its other processes. Both of these features make possible the use of pointers and function calls---as well as many compiler optimizations. At the middleware level, Diaktoros improves navigational programming with an enhanced, highly efficient daemon system. Through marshalling, spatial locality is improved, thus improving performance. By marshalling both the stack and the heap of a running agent, the true state can be migrated in a machine-independent form. This allows the system to work in heterogeneous networks, leading to further performance improvement through the additional processing power made available. The improvements at both the compiler and middleware levels were implemented assuming general-purpose hardware. The logical progression of the research, however, pointed towards the possibility of special purpose hardware for navigational programming. It is possible to simulate the effect of some of this hardware prior to development, which was done here. These simulations proved that the development of dedicated hardware could have a significant positive effect on the performance of mobile agent systems. The combination of improvements at all of these levels establishes that navigational programming can be an efficient method for high-performance distributed computing.

MESSENGERS is a system for general-purpose distributed computing based on the concept of autonomous mobile objects, capable of navigating through a network and invoking native-mode C functions in the nodes they visit. We present performance measurements using three specific applications to illustrate the cost of using this paradigm for developing and using distributed applications.

Class creation by set operations has largely been ignored in the literature. Precise semantics of set operations on complex objects require a clear distinction between the dual notions of a set and a type, both of which are present in a class. Our paper fills this gap by presenting a framework for executing set-theoretic operations on the class construct. The proposed set operations determine both the type description of the derived class as well as its set membership. For the former, we develop inheritance rules for property characteristics such as single- versus multi-valued and required versus optional. For the later, we borrow the object identity concept from data modeling research. Our framework allows for property inheritance among classes that are not necessarily is a related.

In this paper, we propose a new direction for distributive join operations. We assume that there will be a scalable distributed computer system in which many computers (processors) are connected through a communication network that can be in a LAN or as part of the Internet with sufficient bandwidth. A relational database is then distributed across this network of processors. However, in our approach, the distribution of the database is very fine-grained and is based on the Distributed Hash Table (DHT) concept. A tuple of a table is assigned to a specific processor by using a fair hash function applied to its key value. For each joinable attribute, an inverted file list is further generated and distributed again based on the DHT. This pre-distribution is done when the tuple enters the system and therefore does not require any distribution of data tuples on the fly when the join is executed. When a join operation request is broadcast, each processor performs a local join and the results are sent back to a query processor which, in turn, merges the join results and returns them to the user. Note that the distribution of the DHT of the inverted file lists can be either preprocessed or distributed on the fly. If the lists are preprocessed and distributed, they have to be maintained. We evaluate our approach by comparing it empirically to two other approaches: the naive join method and the fully distributed join method. The results show a significantly higher performance of our method for a wide range of possible parameters.

We describe an environment for distributed computing that uses the concept of well-known paradigms. The main advantage of paradigm-oriented distributed computing is that the user only needs to specify application-specific sequential code, while the underlying infrastructure takes care of the parallelization and distribution. The main features of the proposed approach, called PODC, are the following: (1) It is intended for loosely-coupled network environments, not specialized multiprocessors; (2) it is based on an infrastructure of mobile agents; (3) it supports programming in C, rather than a functional or special-purpose language, and (4) it provides a Web-based interactive graphics interface through which programs are constructed, invoked, and monitored. The three paradigms presently supported in PODC are the bag-of-tasks, branch-and-bound search, and genetic programming. We demonstrate their use, implementation, and performance within the mobile agent-based PODC environment.

MESSENGERS is a paradigm for the programming of distributed systems. It is based on the principles of autonomous messages, called Messengers, which carry their own behavior in the form of a program. This enables them to navigate freely in the underlying computational network, communicate with one another, and invoke pre-compiled node-resident functions. Coordination is facilitated at two distinct levels of abstraction: first, Messengers coordinate the invocation and the exchange of data among the various functions distributed throughout the network in both time and space (intra-object coordination); second, Messengers, each representing a high-level entity, can coordinate their behaviors among themselves (inter-object coordination). These principles, where an application is composed of autonomous, mobile entities whose behaviors may change dynamically and which can coordinate their actions among themselves, offer great flexibility in interacting with and manipulating the application at run time, as well as improved performance. This is illustrated using two concrete examples—a Toxicology simulation from medicine and a study of collective fish behavior from biology.

We show how a series of transformations can be applied to incrementally parallelize sequential programs. Our navigational programming (NavP) methodology is based on the principle of self-migrating computations and is truly incremental, in that each step represents a functioning program and every intermediate program is an improvement over its predecessor. The transformations are mechanical and straightforward to apply. We illustrate our methodology in the context of matrix multiplication. Our final stage is similar to the classical Gentleman's algorithm. The NavP methodology is conducive to new ways of thinking that lead to ease of programming and high performance.

One approach to distributed parallel programming is to utilize self-migrating threads. Computations can be distributed first, and parallelized second. The first step produces a distributed sequential thread, which can be incrementally parallelized by the second step. This paper prescribes three transformations that turn distributed sequential programs into distributed parallel programs. Real-life examples and performance data are presented, and the advantages of our approach are discussed.