Programming Style Research Articles

Head first python

Python is a widely used for both learning and real world programming and it is high-level object-oriented programming language created by Guido van Rossum and first released in 1991. Python features a dynamic type system and automatic memory management and supports multiple programming paradigms, including object-oriented, imperative, functional programming, and procedural styles. It has a large and comprehensive standard library. In this research journal paper I want to saw you about introduction about python programming, characteristics of python programming and features of python. In this paper we will also discuss about how python growing faster than the other languages in the recent time supported by research done over the articles procured from various magazines, popular websites and popular computer companies. In this paper I also explain python features, applications, types of programming supported by python and its users. Then at last I will saw you future of python.

Gradual type theory

AbstractGradually typed languages are designed to support both dynamically typed and statically typed programming styles while preserving the benefits of each. Sound gradually typed languages dynamically check types at runtime at the boundary between statically typed and dynamically typed modules. However, there is much disagreement in the gradual typing literature over how to enforce complex types such as tuples, lists, functions and objects. In this paper, we propose a new perspective on the design of runtime gradual type enforcement: runtime type casts exist precisely to ensure the correctness of certain type-based refactorings and optimizations. For instance, for simple types, a language designer might desire that beta-eta equality is valid. We show that this perspective is useful by demonstrating that a cast semantics can be derived from beta-eta equality. We do this by providing an axiomatic account program equivalence in a gradual cast calculus in a logic we callgradual type theory(GTT). Based on Levy’s call-by-push-value, GTT allows us to axiomatize both call-by-value and call-by-name gradual languages. We then show that we can derive the behavior of casts for simple types from the corresponding eta equality principle and the assumption that the language satisfies a property calledgraduality, also known as the dynamic gradual guarantee. Since we can derive the semantics from the assumption of eta equality, we also receive a useful contrapositive: any observably different cast semantics that satisfies gradualitymustviolate the eta equality. We show the consistency and applicability of our axiomatic theory by proving that a contract-based implementation using the lazy cast semantics gives a logical relations model of our type theory, where equivalence in GTT implies contextual equivalence of the programs. Since GTT also axiomatizes the dynamic gradual guarantee, our model also establishes this central theorem of gradual typing. The model is parameterized by the implementation of the dynamic types, and so gives a family of implementations that validate type-based optimization and the gradual guarantee.

Toward software artifacts ecosystem

In the process of developing and maintaining a software product, many things are created and used that are called software artefacts. Software artifacts are created, changed, reused, and change relationships in the development and maintenance processes of a software product. The complexity and variety of software artifact relationships require adequate means of description and management. They may be a software artifacts ecosystem. In the article, for the first time, a concept of a software artifact ecosystem is proposed. The concept describes a generic model of the software artifacts ecosystem, which is the Cornerstone ecosystem type and consists of three actors — the platform, the software, and the artifact. Based on the generic model, the SD model of the software artifacts ecosystem is described. The roles of actors in the ecosystem are indicated, the relationships between actors are described. The developer's activities will be more efficient, the software is understandable, and the development and maintenance is cheaper when the styles (standards) are used. As case study, based on the generic model of the software artifacts ecosystem, a declarative model of the programming style ecosystem has been developed. Three-level model of programming style artifact is proposed. The tools and processes for creating and using a programming style artifact are developed and described.

Designing types for R, empirically

The R programming language is widely used in a variety of domains. It was designed to favor an interactive style of programming with minimal syntactic and conceptual overhead. This design is well suited to data analysis, but a bad fit for tools such as compilers or program analyzers. In particular, R has no type annotations, and all operations are dynamically checked at run-time. The starting point for our work are the two questions: what expressive power is needed to accurately type R code? and which type system is the R community willing to adopt? Both questions are difficult to answer without actually experimenting with a type system. The goal of this paper is to provide data that can feed into that design process. To this end, we perform a large corpus analysis to gain insights in the degree of polymorphism exhibited by idiomatic R code and explore potential benefits that the R community could accrue from a simple type system. As a starting point, we infer type signatures for 25,215 functions from 412 packages among the most widely used open source R libraries. We then conduct an evaluation on 8,694 clients of these packages, as well as on end-user code from the Kaggle data science competition website.

An Event-Based Programming Model with Geometric Spatial Semantics For Cyber-Physical Production Systems

With the increasing complexities, such as massive computing devices and strict requirements for collaboration, of industrial production systems, the concept of the cyber-physical production system (CPPS) is considered as a promising approach for addressing these challenges. However, programmability is a challenge in CPPSs. The traditional chimney style of programming requires considerable design effort from engineers to handle the spatiotemporal heterogeneity of cyber-physical model that encompasses computing, temporal, and geometric semantics along with physical dynamics. Thus, an easy-to-use programming model and an integrated programming framework that are suited to this context are required. However, the existing programming models typically fully consider only computing while only partially considering temporal characteristics, and they rarely consider geometric semantics. To solve this problem, this paper proposes a novel event-based programming model, GePro, considering the geometric spatial semantics to realize integrated programming and reduce design effort, especially the reconfiguration of adding new physical devices into the exist system. A prototype of GePro is implemented and verified based on IEC 61499 by the implementation of design and reconfigure assembly CPPS. The results show that using GePro results in a programming time savings of an development life cycle time compared to traditional models for reconfiguration.

Understanding the Impact of Introducing Lambda Expressions in Java Programs

Background: The Java programming language version eight introduced several features that encourage the functional style of programming, including the support for lambda expressions and the Stream API. Currently, there is common wisdom that refactoring legacy code to introduce lambda expressions, besides other potential benefits, simplifies the code and improves program comprehension. Aims: The purpose of this work is to investigate this belief, conducting an in-depth study to evaluate the effect of introducing lambda expressions on program comprehension. Method: We conduct this research using a mixed-method study. For the quantitative method, we quantitatively analyze 166 pairs of code snippets extracted directly either from GitHub or from recommendations from three tools (RJTL, NetBeans, and IntelliJ). We also surveyed practitioners to collect their perceptions about the benefits on program comprehension when introducing lambda expressions. We asked practitioners to evaluate and rate sets of pairs of code snippets. Results: We found contradictory results in our research. Based on the quantitative assessment, we could not find evidence that the introduction of lambda expressions improves software readability—one of the components of program comprehension. Our results suggest that the transformations recommended by the aforementioned tools decrease program comprehension when assessed by two state-of-the-art models to estimate readability. Differently, our findings of the qualitative assessment suggest that the introduction of lambda expression improves program comprehension in three scenarios: when we convert anonymous inner classes to a lambda expression, structural loops with inner conditional to a anyMatch operator, and structural loops to filter operator combined with a collect method. Implications: We argue in this paper that one can improve program comprehension when she applies particular transformations to introduce lambda expressions (e.g., replacing anonymous inner classes with lambda expressions). Also, the opinion of the participants shines the opportunities in which a transformation for introducing lambda might be advantageous. This might support the implementation of effective tools for automatic program transformations.

The Child as Hacker.

The scope of human learning and development poses a radical challenge for cognitive science. We propose that developmental theories can address this challenge by adopting perspectives from computer science. Many of our best models treat learning as analogous to computer programming because symbolic programs provide the most compelling account of sophisticated mental representations. We specifically propose that children's learning is analogous to a particular style of programming called hacking, making code better along many dimensions through an open-ended set of goals and activities. By contrast to existing theories, which depend primarily on local search and simple metrics, this view highlights the many features of good mental representations and the multiple complementary processes children use to create them.

DESIGN TIMED FSM WITH VHDL MOORE PATTERN

Context. The relevance of the work consists in the development of computer-aided design methods for automatic real-time logic control devices by developing a single template in a synthesized subset of the hardware description language in the style of automatabased programming with implementation on the PLD hardware platform (FPGA, CPLD). Development of the description template for timed control finite state machines (FSM) in the hardware description language VHDL, automated synthesis and implementation of the model in PLD (FPGAs, CPLDs) using Xilinx ISE, subsequent analysis of the received circuit implementation for compliance with values of timing parameters of the circuit after implementation.Objective. The aim of the work is to develop principles for constructing models of timed control FSM in the VHDL hardware description language. In this work, we solved the problem of constructing a pattern for describing models of timed control Moore FSM using VHDL, automated synthesis and implementation of the obtained VHDL model in PLDs (FPGA, CPLD) using Xilinx ISE and subsequent analysis of the resulting circuit implementation for compliance with values of timing parameters of the circuit after implementation.Method. Realization of models’ parameters of timed FSM in logical control systems using VHDL statements. Development of VHDL language constructions of timed FSM models for timing parameters implementation that provide the correct automated synthesis and implementation of these models in PLDs (FPGA, CPLD) using CAD tools Xilinx ISE.Results. Synthesis and implementation of proposed templates of VHDL-models of timed control Moore FSM in logic control systems by XILINX ISE CAD tools confirmed the receipt of not redundant circuits in PLD (FPGA, CPLD), and simulation after implementation showed the efficiency of such models.Conclusions. The work solves the problem of computer-aided design of timed control FSM in real-time logic control systems. To solve this problem, VHDL-models of timed control Moore FSM were developed, which made it possible to implement control FSM with time constraints, timeouts and output delays. Automated synthesis and simulation of VHDL models based on the developed templates confirmed the efficiency and correctness of the proposed models.The scientific novelty of the work consists in the further development of methods for constructing templates of HDL models of timed control Moore FSM, which made it possible to implement control FSM with time constraints, timeouts and output delays, as well as perform their correct automated synthesis and simulation.The practical value of results is in the development of procedures for constructing VHDL models of timed Moore control FSM in real-time logic control systems, which made it possible to automate the synthesis of control FSM taking into account the possibility of processing external events and implementing arbitrary delays for output signals and to increase the flexibility and speed of designed systems. The developed procedures can be useful for designers of timed control FSM in Xilinx ISE.

Дескриптивная модель экосистемы стиля программирования

In the process of developing and maintaining a software product, many things are created and used that are called software artefacts. Software artifacts are changed, reused, and change relationships in the development and maintenance processes of a software product. The complexity and variety of software artifact relationships require adequate means of description and management. They may be a software artifact ecosystem. In the article, for the first time, a concept of a software artifact ecosystem is proposed. The concept describes a generalized model of the software artifact ecosystem, which is the Cornerstone ecosystem type and consists of three actors – the platform, the software, and the artifact. The roles of actors in the ecosystem are indicated, the relationships between actors are described. As an example, based on the generalized model of the software artifact ecosystem, a declarative model of the programming style ecosystem has been developed.

Home Smart Home: Approachable Interfaces for Intelligibility, Modification, and End-User Programming

End-user programming concepts are increasingly employed in smart home research to address the growing complexity of controlling smart home environments. Different approaches and visual styles of end-user programming have been proposed and implemented within this context. Smart home control does however not only necessitate end-user programming but also understanding and modifying existing program structures. In this study, we compare three different approaches regarding their suitability for this application context with a specific focus on intelligibility and modification performance. We conducted an empirical study with 39 users performing three types of tasks (understanding, configuring, and programming), using three different approaches for end-user programming (form-filling, data-flow, and grid-canvas). The results of our study found no significant differences regarding the intelligibility of the three different implementations but clear differences in the subjective preference of users as well as configuration and programming performance.

Progressive resistance exercise for improving pain and disability in chronic neck pain: A case series.

Chronic neck pain is known to be associated with neck muscle weakness. However, many strengthening programs do not target multi-directional weakness in a functional position. Specialised assessment and treatment technology that is able to strengthen the neck muscles in an upright position may be used to achieve this. There is little research available on the efficacy of neck-specific progressive resistance exercise interventions in patients with chronic neck pain; therefore, this study aimed to determine whether this style of program led to a change in pain and disability, and to investigate the relationship between neck strength, pain and disability. Secondary analysis of participants with chronic neck pain who completed a minimum of nine sessions of a neck-specific progressive resistance program at a physiotherapy clinic between the years of 2002 and 2018. Outcomes were the Neck Disability Index (NDI), Numerical Rating Scale of Pain (NRS) and multi-directional neck strength (flexion, extension and lateral flexion - pounds). Data were analysed through paired samples t-tests and backwards stepwise multiple linear regression models. A total of 127 participants were eligible for inclusion. All neck strength measures, NDI scores and NRS scores showed significant improvements after the nine sessions (all p < .0001). Significant predictors of NDI were symptom duration (β = -0.023, p = .009) and NRS score (β = 4.879, p < .000). Significant predictors of NRS were symptom duration (β = 0.004, p = .005), NDI score (β = 0.105, p < .000), extension strength (β = -0.950, p = .012) and gender (β = 0.777 [male =1, female = 0], p = .029). This study showed that a neck-specific progressive resistance exercise intervention led to significant improvement in neck strength, pain and disability in a clinical population. However, caution should be taken when interpreting results due to a lack of comparison group and the variation in treatment given and, therefore, further higher-quality research should be undertaken to confirm these findings.

Programmable Logic Controllers in the Context of Industry 4.0

Programmable logic controllers (PLCs) are an established platform, widely used throughout industrial automation but poorly understood among researchers. This article gives an overview of the state of the practice, explaining why this settled technology persists throughout industry and presenting a critical analysis of the strengths and weaknesses of the dominant programming styles for today's PLC-based automation systems. We describe the software execution patterns that are standardized loosely in IEC 61131-3. We identify opportunities for improvements that would enable increasingly complex industrial automation applications while strengthening safety and reliability. Specifically, we propose deterministic, distributed programming models that embrace explicit timing, event-triggered computation, and improved security.

Identifying distance learners’ learning styles

This study aimed to identify the learning styles of distance learners studying for an associate’s degree in computer programming and child development and to determine whether there is a difference between the departments. Accordingly the survey model was used in this study. The sample consisted of 261 associate’s degree students enrolled in two distance education programs. The data were collected using the E-Learning Styles Scale. In the data analysis, categories were formed using the mean scores on the E-Learning Styles Scale to identify the dominant -e-learning styles of the students and the nonparametric Mann-Whitney U test was used because of The data were not normally distributed. The analysis results showed that the most preferred learning style of computer programming and child development students was the independent e-learning style. The preferred learning styles of computer programming and child development students differed in active learning, social learning, and logical learning styles.

Effect of the Interpersonal Autonomy-Supportive Teaching Style on the Professional Training of Lifeguards

The objective of this study was to analyze the motivational, behavioral, and cognitive effect of autonomy support in rescue and lifesaving classes within the framework of the self-determination theory. The sample consisted of 40 students aged from 19 to 26 years old (M = 20.83; TD = 1.86). Students were randomly divided into the intervention (n = 19) and control (n = 21) groups. The following were measured: the perception of the autonomy-supportive and controlling interpersonal styles, the social support for the basic psychological needs of the professor, the satisfaction of the basic psychological needs, and the aquatic competence in rescue and lifeguarding. After the application of the program, improvements were observed in the intervention group in the variables of perception of autonomy support, social support for autonomy, and competence; satisfaction of the basic psychological needs for autonomy and competence; and improvement of the cognitive and behavioral processes of aquatic competence in rescue and lifeguarding. The findings show the effectiveness of the interpersonal teaching style of the autonomy-support program by obtaining more positive results at the motivational, behavioral, and cognitive levels, as opposed to a controlling interpersonal style.

Query-based object-oriented programming: a declarative web of objects

We present a declarative, object-oriented language in which queries play a central role. Queries are used not only to access data, but also to refer to the application’s object members and as a means of program control. The language is fully declarative, with queries and other pure functions defining the relations between the attributes of different objects. A rule-base-like write operation allows state to be updated. Control is achieved by queries selecting the class variants (mixin classes) which are active in each object. The dynamic activation and deactivation of declarative mixin classes allows decomposition of functionality into small reusable classes. The programming style in the language is functional and reactive, with function applications defining object members. Queries are one type of function, which also serves as the glue which puts these functions together, providing them with their input. Since queries describe declaratively what they return, they leave it to the system to implement the how of getting it. Combining this with an organization around objects makes the language highly suitable for complex interactive applications driven by large amounts of data from multiple sources. Our implementation of the language includes a strong display component. It can be seen as a conceptual extension of HTML and CSS in a way which replaces the need for the JavaScript imperative component in web applications. The work described here is not restricted, however, to front-end development and can be applied elsewhere as well.

SEX AND AGE-BASED DIFFERENCES IN PEDIATRIC BASKETBALL INJURIES

Background:There is limited epidemiologic data on pediatric basketball injuries and the correlation of these injuries with sex-based differences pre- and post-adolescence.Purpose:To describe sex and age-based injury rates associated with common pediatric basketball injuries.Methods:A descriptive epidemiology study was conducted utilizing publicly available injury data from the National Electronic Injury Surveillance System (NEISS) and participation data from the National Sporting Goods Association (NSGA). Data on pediatric basketball injuries from January 2012 – December 2018 in patients ages 7-17 years were extracted and used to calculate national injury incidence rates with 95% confidence intervals.Results:Over 7 years, 9,582 basketball injuries were reported annually in the NEISS in pediatric patients 7-17 years old, which corresponds to an annual national estimate of 294,920 visits.The 5 most common diagnoses were ankle strain/sprain (17.7%), finger strain/sprain and finger fracture (12.1%), concussion/head injury (9.4%), knee strain/sprain (4.5%), and facial laceration (3.3%).There was a notable increase in injury rate in adolescents when compared with childhood ages; 7- to 11-year-old category accounted for 19.1% of estimated injuries (56,242 injuries per year) and the 12- to 17-year-old category accounted for 80.9% (238,678 injuries per year). While boys accounted for the majority of injuries in both age groups [72.6% of all injuries (40,824 injuries per year) in the 7- to 11-year-old category and 74.4% of all injuries (177,572 injuries per year) in the 12- to 17-year-old category], overall, there was no significant difference in injury rate between boys and girls (boys: 91 injuries per 100,000 athlete days, 95% CI = 73-109; girls: 110 injuries per 100,000 athlete days, 95% CI = 92-128; p=0.140). Overall injury rates across the two age groups are reported in Table 1.Head injuries/concussions were a frequent cause of presentation (second only to finger injuries) in 7- to 11-year-olds, and occurred at a similar rate in girls and boys. In adolescents, ankle injuries were the most common injury overall, but there was a most notable increase in the rate of girls’ head and knee injury compared with their boy counterparts within these ages (Table 1).Conclusions:Ankle injuries continue to be the most predominant pediatric basketball injury. However, disproportionate rates of girls’ head and knee injuries during adolescent basketball suggest that style of play and knee injury prevention programs should target girls participating in youth basketball.Table 1.Rate of basketball injuries treated in US emergency departments in the NEISS from 2012-2018a Variables7- to 11-Year-Oldsp-value12- to 17-Year-Oldsp-valueBoysGirlsBoysGirls Ankle Strain/Sprain 3.4 (2.6-4.2)6.1 (4.9-7.3)0.000223.5 (19.2-27.8)27.1 (22.4-31.8)0.2688 Finger Strain/Sprain/Fracture 8.0 (6.4-9.6)13.8 (10.5-17.1)0.002011.5 (9.1-13.9)17.4 (14.3-20.5)0.0032 Concussion/Head Injury 5.9 (4.3-7.5)4.9 (3.1-6.7)0.40638.5 (6.7-10.3)19 (15.1-22.9)<0.0001 Knee Strain/Sprain 1.4 (1-1.8)1.6 (1.2-2)0.47954.9 (3.7-6.1)10.2 (8.2-12.2)<0.0001 Facial Laceration 1.5 (1.1-1.9)0.5 (0.3-0.7)<0.00014.8 (3.8-5.8)2.4 (1.8-3)<0.0001 Overall Injuries 46.7 (37.1-56.3)57.9 (47.1-68.7)0.1284116.6 (93.5-139.7)142.9 (119.6-166.2)0.1166 Overall Injuries 49.3 (39.7-58.9)-122.4 (99.9-144.9)<0.0001 a No. of injuries per 100,000 athlete days (95% confidence interval)

DiffPageRank: an efficient differential PageRank approach in MapReduce

Unstructured big data processing requires efficient computational styles to rapidly analyze continuously changing data. Incremental processing is a promising technique to update search results without re-computing the whole process. One of the most important mining algorithms is PageRank which necessitates incremental processing and iterative computations to keep the mining results up-to-date. In this paper, a light and efficient PageRank algorithm is proposed using differential dataflow in the MapReduce programming style named DiffPageRank. The innovation of the proposed approach is investigated from two points of view: (1) the updating state is dependent on a partial order of changes in DiffPageRank computing, while the changes are applied based on complete order sequences in the standard incremental computing; and (2) in DiffPageRank, a set of updates rebuilds each version, while in the incremental systems, every single update continually bring up-to-date the current version state. DiffPageRank is compared with two other implementations of PageRank including standard and incremental PageRank in MapReduce in terms of processing time, CPU utilization and update speed of data mining results. The results show that if the changes on the input data are large, the efficiency of the differential method will considerably increase in terms of time than the standard and incremental PageRank approaches up to 61% and 86%, respectively. DiffPageRank is also compared with two state-of-the-art incremental graph processing benchmarks on Orkut and Twitter datasets in terms of execution time and the number of updates. The experimental comparisons on benchmark datasets show that our method reduces the number of updates and total execution time by using the differential MapReduce approach.

Bigflow: A General Optimization Layer for Distributed Computing Frameworks

As data volumes grow rapidly, distributed computations are widely employed in data-centers to provide cheap and efficient methods to process large-scale parallel datasets. Various computation models have been proposed to improve the abstraction of distributed datasets and hide the details of parallelism. However, most of them follow the single-layer partitioning method, which limits developers to express a multi-level partitioning operation succinctly. To overcome the problem, we present the NDD (Nested Distributed Dataset) data model. It is a more compact and expressive extension of Spark RDD (Resilient Distributed Dataset), in order to remove the burden on developers to manually write the logic for multi-level partitioning cases. Base on the NDD model, we develop an open-source framework called Bigflow, which serves as an optimization layer over computation engines from most widely used processing frameworks. With the help of Bigflow, some advanced optimization techniques, which may only be applied by experienced programmers manually, are enabled automatically in a distributed data processing job. Currently, Bigflow is processing about 3 PB data volumes daily in the data-centers of Baidu. According to customer experience, it can significantly save code length and improve performance over the intuitive programming style.

Everyone Loves File

Oracle File Storage Service (FSS) is an elastic filesystem provided as a managed NFS service. A pipelined Paxos implementation underpins a scalable block store that provides linearizable multipage limited-size transactions. Above the block store, a scalable B-tree holds filesystem metadata and provides linearizable multikey limited-size transactions. Self-validating B-tree nodes and housekeeping operations performed as separate transactions allow each key in a B-tree transaction to require only one page in the underlying block transaction. The filesystem provides snapshots by using versioned key-value pairs. The system is programmed using a nonblocking lock-free programming style. Presentation servers maintain no persistent local state making them scalable and easy to failover. A non-scalable Paxos-replicated hash table holds configuration information required to bootstrap the system. An additional B-tree provides conversational multi-key minitransactions for control-plane information. The system throughput can be predicted by comparing an estimate of the network bandwidth needed for replication to the network bandwidth provided by the hardware. Latency on an unloaded system is about 4 times higher than a Linux NFS server backed by NVMe, reflecting the cost of replication. FSS has been in production since January 2018 and holds tens of thousands of customer file systems comprising many petabytes of data.

Bacatá: Notebooks for DSLs, Almost for Free

Context: Computational notebooks are a contemporary style of literate programming, in which users can communicate and transfer knowledge by interleaving executable code, output, and prose in a single rich document. A Domain-Specific Language (DSL) is an artificial software language tailored for a particular application domain. Usually, DSL users are domain experts that may not have a software engineering background. As a consequence, they might not be familiar with Integrated Development Environments (IDEs). Thus, the development of tools that offer different interfaces for interacting with a DSL is relevant. Inquiry: However, resources available to DSL designers are limited. We would like to leverage tools used to interact with general purpose languages in the context of DSLs. Computational notebooks are an example of such tools. Then, our main question is: What is an efficient and effective method of designing and implementing notebook interfaces for DSLs? By addressing this question we might be able to speed up the development of DSL tools, and ease the interaction between end-users and DSLs. Approach: In this paper, we present Bacat\'a, a mechanism for generating notebook interfaces for DSLs in a language parametric fashion. We designed this mechanism in a way in which language engineers can reuse as many language components (e.g., language processors, type checkers, code generators) as possible. Knowledge: Our results show that notebook interfaces generated by Bacat\'a can be automatically generated with little manual configuration. There are few considerations and caveats that should be addressed by language engineers that rely on language design aspects. The creation of a notebook for a DSL with Bacat\'a becomes a matter of writing the code that wires existing language components in the Rascal language workbench with the Jupyter platform. Grounding: We evaluate Bacat\'a by generating functional computational notebook interfaces for three different non-trivial DSLs, namely: a small subset of Halide (a DSL for digital image processing), SweeterJS (an extended version of JavaScript), and QL (a DSL for questionnaires). Additionally, it is relevant to generate notebook implementations rather than implementing them manually. We measured and compared the number of Source Lines of Code (SLOCs) that we reused from existing implementations of those languages. Importance: The adoption of notebooks by novice-programmers and end-users has made them very popular in several domains such as exploratory programming, data science, data journalism, and machine learning. Why are they popular? In (data) science, it is essential to make results reproducible as well as understandable. However, notebooks are only available for GPLs. This paper opens up the notebook metaphor for DSLs to improve the end-user experience when interacting with code and to increase DSLs adoption.