The effectiveness of traces as a tool for understanding programs is well understood, however, research shows that [2, 3] students remain reluctant to use tracing, preferring to quickly write programs and use debuggers in an unsystematic, trial and error fashion.We report here some experiments that evaluate the effectiveness of a different approach called trace-first [4], where we ask students to create traces by analyzing problems, before they write code.The analysis derives intended behavior and then convert it to code.To investigate the impact of using traces as both an analysis and design tool, we conducted a pre/post study (n=29) with students solving programming problems.In the pre-test, students approached problems without explicit guidance on tracing.We then taught them to use traces to plan intended behavior, and then develop programs.We find that more students get programs correct, and surveys show evidence that students find traces a helpful tool for problem analysis and program design. CCS Concepts• Social and professional topics

Self-regulation refers to the ability to plan, monitor, control and reflect on one's problem-solving process. Prior research has shown that self-regulated learning (SRL) strategies help improve novice performance in solving programming problems. However, with the advent of LLM tools like ChatGPT, novices can generate fairly accurate code by just providing the problem prompt, and hence may forego applying essential self-regulation strategies such as planning and reflection to solve the problem.

Phase separation of proteins play key roles in cellular physiology including bacterial division, tumorigenesis etc. Consequently, understanding the molecular forces that drive phase separation has gained considerable attention and several factors including hydrophobicity, protein dynamics, etc., have been implicated in phase separation. Data-driven identification of new phase separating proteins can enable in-depth understanding of cellular physiology and may pave way towards developing novel methods of tackling disease progression. In this work, we exploit the existing wealth of data on phase separating proteins to develop sequence-based machine learning method for prediction of phase separating proteins. We use reduced alphabet schemes based on hydrophobicity and conformational similarity along with distributed representation of protein sequences and biochemical properties as input features to Support Vector Machine (SVM) and Random Forest (RF) machine learning algorithms. We used both curated and balanced dataset for building the models. RF trained on balanced dataset with hydropathy, conformational similarity embeddings and biochemical properties achieved accuracy of 97%. Our work highlights the use of conformational similarity, a feature that reflects amino acid flexibility, and hydrophobicity for predicting phase separating proteins. Use of such "interpretable" features obtained from the ever-growing knowledgebase of phase separation is likely to improve prediction performances further.

In practice, programmers start with informal requirements proposed by a customer, make the requirements precise, and implement them in a program that meets the customers needs. It is difficult for a CS1 course to convey a sense of this journey to students, since they need to understand the notional machine, technological artifacts, and the informal to formal transition at the same time. In this paper we show how to sequence the teaching of programming ideas in such a way that in a short two-month course, novice students learn to develop simple programming projects from requirements in English to a working program. We start by showing that programs are an extension of school algebra using Pugofer, a pedagogical Haskell-like language. Then we present list comprehensions, which lets us create simple programs with lists and tuples as handy "databases''. Next we teach requirements analysis for information processing situations such as library management, and create programs that represent domain concepts using data, and behaviors using functions and comprehensions. Students follow this process in their own projects. We end by teaching recursion, motivating it as a way to implement comprehensions. We have taught courses in this style three times; each time students have delivered projects as well as standard CS1 exams, and rated the course highly. It has been easy to move to imperative programming in later courses. We believe that our approach can be readily replicated, giving students the benefit of experiencing key elements of the software lifecycle early in their CS education.

Search, exploration and social experience on the Web has recently undergone tremendous changes with search engines, web portals and social networks offering a different perspective on information discovery and consumption. This new perspective is aimed at capturing user intents, and providing richer and highly connected experiences. The new battleground revolves around technologies for the ingestion, disambiguation and enrichment of entities from a variety of structured and unstructured data sources - we refer to this process as knowledge base synthesis. This paper presents the design, implementation and production deployment of the Web Of Objects (WOO) system, a Hadoop-based platform tackling such challenges. WOO has been designed and implemented to enable various products in Yahoo! to synthesize knowledge bases (KBs) of entities relevant to their domains. Currently, the implementation of WOO we describe is used by various Yahoo! properties such as Intonow, Yahoo! Local, Yahoo! Events and Yahoo! Search. This paper highlights: (i) challenges that arise in designing, building and operating a platform that handles multi-domain, multi-version, and multi-tenant disambiguation of web-scale knowledge bases (hundreds of millions of entities), (ii) the architecture and technical solutions we devised, and (iii) an evaluation on real-world production datasets.

User facing topical web applications such as events or shopping sites rely on large collections of data records about real world entities that are updated at varying latencies ranging from days to seconds. For example, event venue details are changed relatively infrequently whereas ticket pricing and availability for an event is often updated in near-realtime. Users regard these sites as high quality if they seldom show duplicates, the URLs are stable, and their content is fresh, so it is important to resolve duplicate entity records with high quality and low latencies. High quality entity resolution typically evaluates the entire record corpus for similar record clusters at the cost of latency, while low latency resolution examines the least possible entities to keep time to a minimum, even at the cost of quality. In this paper we show how to keep low latency while achieving high quality, combining the best of both approaches: given an entity to be resolved, our incremental Fastpath system, in a matter of milliseconds, makes approximately the same decisions that the underlying batch system would have made. Our experiments show that the Fastpath system makes matching decisions for previously unseen entities with 90% precision and 98% recall relative to batch decisions, with latencies under 20ms on commodity hardware.

We make two observations about communications middleware: first, most middleware are similar, the differences are in their interfaces and optimizations; second, neither a fixed set of abstractions nor a fixed implementation of a set of abstractions is likely to be sufficient and well-performing for all applications. Based on these observations, we present Quarterware, a customizable middleware architecture. It abstracts basic middleware functionality, and admits application specific specializations and extensions. We demonstrate its flexibility by deriving implementations for core facilities of CORBA, RMI, and MPI. The performance results show that the derived implementations equal or exceed the performance of corresponding native versions. These results suggest that customizing middleware on a per-application basis is an effective approach for building robust, high-performance applications.

Tracking the changing dynamics of object-oriented frameworks[5], design patterns[7], architectural styles[8], and subsystems during the development and reuse cycle can aid producing complex systems. Unfortunately, current object-oriented programming tools are relatively oblivious to the rich architectural abstractions in a system.This paper shows that architecture-oriented visualization, the graphical presentation of system statics and dynamics in terms of its architectural abstractions, is highly beneficial in designing complex systems. In addition, the paper presents architecture-aware instrumentation, a new technique for building efficient on-line instrumentation to support architectural queries. We demonstrate the effectiveness and performance of the scheme with case studies in the design of the Choices object-oriented operating system.

Software specification and implementation techniques based on state machines simplify design, coding, and validation. However, large systems require complex state machines. Incremental construction techniques can control this complexity. In this paper, we present a construction technique that permits derivation of complex state machines from simpler state machines. The technique uses subclassing, composition, delegation, and genericity to incrementally modify and combine simpler machines.In addition, we present a novel implementation technique that uses exactly one table-lookup and one addition to dispatch events on derived state machines, no matter the depth of the derivation. As an example, we describe the derivation of a complicated distributed virtual memory scheme from a simple paging virtual memory scheme.

No abstract available.