Discover the world's research
- 20+ million members
- 135+ million publications
- 700k+ research projects
Join for free
Programming Language Pragmatic s
THIRD EDITIO N
Michael L. Scot t
Department of
Computer Science
University
of Rochester
^ШШШШШ AMSTERDAM • BOSTON • HEIDELBERG • LONDON
,¥'-*i» ЩЛ<
^ 'mH NEW YORK «OXFORD «PARIS »SAN DIEGO ^k^B V\A®
jfce§f$fa
SAN FRANCISCO • SINGAPORE • SYDNEY • TOKYO ^^^И к.^
ELSEVIER
Morgan Kaufmann Publishers is
an
imprint of Elsevier MORGAN KAUFMANN PUBLISHERS
Contents
Foreword xx i
Preface xxii i
FOUNDATIONS з
1 Introduction 5
I.
I
The Art of Language Design 7
1.2 The Programming Language Spectrum 1 0
1.3 Why Study Programming Languages? 1 4
1.4 Compilation and Interpretation 1 6
1.5 Programming Environments 2 4
1.6 An Overview of Compilation 2 5
1.6.1 Lexical and Syntax Analysis 2 7
1.6.2 Semantic Analysis and Intermediate Code Generation 2 9
1.6.3 Target Code Generation 3 3
1.6.4 Code Improvement 33
1.7 Summary and Concluding Remarks 3 5
1.8 Exercises 3 6
1.9 Explorations 3 7
1.10 Bibliographic Notes 3 9
2 Programming Language Syntax 4 1
2.1 Specifying Syntax: Regular Expressions and Context-Free Grammars 4 2
2.1.1 Tokens and Regular Expressions 4 3
2.1.2 Context-Free Grammars 4 6
2.1.3 Derivations and
Parse
Trees 48
2.2 Scannin g
2.2.1 Generating a Finite Automato n
2.2.2 Scanner Cod e
2.2.3 Table-Driven Scannin g
2.2.4 Lexical Error s
2.2.5 Pragma s
2.3 Parsin g
2.3.1 Recursive Descen t
2.3.2 Table-Driven Тор-Down Parsin g
2.3.3 Bottom-Up Parsin g
2.3.4 Syntax Error s
2.4 Theoretical Foundation s
2.4.1 Finite Automat a
2.4.2 Push-Down Automat a
2.4.3 Grammar and Language Classes
2.5 Summary and Concluding Remark s
2.6 Exercise s
2.7 Exploration s
2.8 Bibliographic Note s
Names, Scopes, and Binding s
3.1 The Notion of
Binding
Time
3.2 Object Lifetime and Storage Managemen t
3.2.1 Static Allocatio n
3.2.2 Stack-Based Allocatio n
3.2.3 Heap-Based Allocatio n
3.2.4 Garbage Collectio n
3.3 Scope Rule s
3.3.1 Static Scopin g
3.3.2 Nested Subroutine s
3.3.3 Declaration Orde r
3.3.4 Module s
3.3.5 Module Types and Classe s
3.3.6 Dynamic Scopin g
3.4 Implementing Scop e
3.4.1 Symbol Table s
3.4.2 Association Lists and Central ReferenceTab l
3.5 The Meaning of Names within a Scop e
3.5.1 Aliase s
3.5.2 Overloadin g
3.5.3 Polymorphism and Related Concept s
3.6 The Binding of Referencing Environment s
3.6.1 Subroutine Closure s
3.6.2 Fi rst-Class
Values
and Unlimited Extent
3.6.3 Object Closure s
3.7 Macro Expansio n
3.8 Separate Compilatio n
3.8.1 Separate Compilation in С
3.8.2 Packages and Automatic Header Inferenc e
3.8.3 Module Hierarchie s
3.9 Summary and Concluding Remark s
3.10 Exercise s
3.1 I Exploration s
3.12 Bibliographic Note s
4 Semantic Analysi s
4.1 The Role of the Semantic Analyze r
4.2 Attribute Grammar s
4.3 Evaluating Attribute s
4.4 Action Routine s
4.5 Space Management for Attribute s
4.5.1 Bottom-Up Evaluatio n
4.5.2 Тор-Down Evaluatio n
4.6 Decorating a Syntax Tre e
4.7 Summary and Concluding Remark s
4.8 Exercise s
4.9 Exploration s
4.10 Bibliographic Note s
5 Target Machine Architectur e
5.1 The Memory Hierarch y
5.2 Data Representatio n
5.2.1 Integer Arithmeti c
5.2.2 Floating-Point Arithmeti c
s i
5.3 Instruction Set Architectur e
5.3.1 Addressing Mode s
5.3.2 Conditions and Branche s
5.4 Architecture and Implementatio n
5.4.1 Microprogrammin g
5.4.2 Microprocessor s
5.4.3 RIS C
5.4.4 Multithreading and Multicor e
5.4.5 Two Example Architectures: The x86 and MIP S
5.5 Compiling for Modern Processor s
5.5.1 Keeping the Pipeline Ful l
5.5.2 Register Allocatio n
5.6 Summary and Concluding Remark s
5.7 Exercise s
5.8 Exploration s
5.9 Bibliographic Note s
CORE ISSUES IN LANGUAGE DESIG N
6 Control Flo w
6.1 Expression Evaluatio n
.
I
Precedence and Associativity
.2 Assignment s
.3 Initializatio n
.4 Ordering within Expression s
.5 Short-Circuit Evaluatio n
6.2 Structured and Unstructured Flo w
6.2.1 Structured Alternatives to got o
6.2.2 Continuation s
6.3 Sequencin g
6.4 Selectio n
6.4.1 Short-Circuited Condition s
6.4.2 Case/Switch Statement s
6.5 Iteratio n
6.5.1 Enumeration-Controlled Loop s
6.5.2 Combination Loop s
6.5.3 Iterator s
6.5.4 Generators in Ico n
6.5.5 Logically Controlled Loop s
6.6 Recursio n
6.6.1 Iteration and Recursio n
6.6.2 Applicative- and Normal-Order Evaluatio n
6.7 Nondeterminac y
6.8 Summary and Concluding Remark s
6.9 Exercise s
6.10 Exploration s
6.1 I Bibliographic Note s
Data Type s
7.1 Type Systems
7.1.1 Type Checkin g
7.1.2 Polymorphis m
7.1.3 The Meaning of "Typ e
7.1.4 Classification of Type s
7.1.5 Orthogonalit y
7.2 Type Checkin g
7.2.1 Type Equivalenc e
7.2.2 Type Compatibilit y
7.2.3 Type Inferenc e
7.2.4 The ML Type Syste m
7.3 Records (Structures) and Variants (Unions )
7.3.1 Syntax and Operation s
7.3.2 Memory Layout and Its Impac t
7.3.3 With Statement s
7.3.4 Variant Records (Unions )
7.4 Array s
7.4.1 Syntax and Operation s
7.4.2 Dimensions, Bounds, and Allocatio n
7.4.3 Memory Layou t
7.5 String s
7.6 Set s
7.7 Pointers and Recursive Type s
7.7.1 Syntax and Operation s
xiv Content s
149
•
153
•
153
154
156
• 356
357
364
• 367
368
371
373
379
380
7.7.2 Dangling Reference s
7.7.3 Garbage Collectio n
7.8 List s
7.9 Files and Input/Outpu t
7.9.1 Interactive I/ O
7.9.2 File-Based I/ O
7.9.3 Text I/ O
7.10 Equality
Testing
and Assignment
7.1 I Summary and Concluding Remark s
7.12 Exercise s
7.13 Exploration s
7.14 Bibliographic Note s
8 Subroutines and Control Abstraction 38 3
8.1 Review of Stack Layout 38 4
8.2 Calling Sequences 38 6
8.2.1 Displays ©169 • 389
8.2.2 Case Studies: С on the MIPS; Pascal on the x86 © 173 • 389
8.2.3 Register Windows ©181 • 390
8.2.4 In-Line Expansion 391
8.3 Parameter Passing 39 3
8.3.1 Parameter Modes 394
8.3.2 Call-by-Name ©185 • 402
8.3.3 Special-Purpose Parameters 403
8.3.4 Function Returns 408
8.4 Generic Subroutines and Modules 41 0
8.4.1 Implementation Options 412
8.4.2 Generic Parameter Constraints 414
8.4.3 Implicit Instantiation 416
8.4.4 Generics in C++,
Java,
and C# ©189 • 417
8.5 Exception Handling 41 8
8.5.1 Defining Exceptions 421
8.5.2 Exception Propagation 423
8.5.3 Implementation of Exceptions 425
8.6 Coroutines 42 8
8.6.1 Stack Allocation 430
8.6.2 Transfer 432
Contents X V
8.6.3 Implementation of Iterators ©201 • 433
8.6.4 Discrete Event Simulation ©205 • 433
8.7 Events 43 4
8.7.1 Sequential Handlers 434
8.7.2 Thread-Based Handlers 436
8.8 Summary and Concluding Remarks 43 8
8.9 Exercises 43 9
8.10 Explorations 44 6
8.1 I Bibliographic Notes 44 7
Data Abstraction and Object Orientation 44 9
9.1 Object-Oriented Programming 45 1
9.2 Encapsulation and Inheritance 46 0
9.2.1 Modules 460
9.2.2 Classes 463
9.2.3 Nesting (Inner Classes) 465
9.2.4 Type Extensions 466
9.2.5 Extending without Inheritance 468
9.3 Initialization and Finalization 46 9
9.3.1 Choosing a Constructor 470
9.3.2 References and Values 472
9.3.3 Execution Order 475
9.3.4 Garbage Collection 477
9.4 Dynamic Method Binding 47 8
9.4.1 Virtual and Nonvirtual Methods 480
9.4.2 Abstract Classes 482
9.4.3 Member Lookup 482
9.4.4 Polymorphism 486
9.4.5 Object Closures 489
9.5 Multiple Inheritance ©215 • 49 1
9.5.1 Semantic Ambiguities ©217
9.5.2 Replicated Inheritance ©220
9.5.3 Shared Inheritance ©222
9.5.4 Mix-ln Inheritance ©223
9.6 Object-Oriented Programming Revisited 49 2
9.6.1 The Object Model of Smalltalk ©227 • 493
9.7 Summary and Concluding Remarks 49 4
xvi Content s
9.8 Exercises
495
9.9 Explorations
498
9.10 Bibliographic Notes
499
ALTERNATIVE PROGRAMMING MODELS
503
10 Functional Languages
505
10.1 Historical Origins
506
10.2 Functional Programming Concepts
507
10.3
A
Review/Overview of Scheme
509
10.3.1 Bindings
512
10.3.2 Listsand Numbers
513
10.3.3 Equality
Testing
and Searching
514
10.3.4 Control Flow and Assignment
515
10.3.5 Programs as Lists
517
10.3.6 Extended Example: DFA Simulation
519
10.4 Evaluation Order Revisited
521
10.4.1 Strictness and Lazy Evaluation
523
10.4.2 I/O: Streams and Monads
525
10.5 Higher-Order Functions
530
10.6 Theoretical Foundations ©237
• 534
10.6.1 Lambda Calculus
©239
10.6.2 Control Flow
©242
10.6.3 Structures
©244
10.7 Functional Programming in Perspective
534
10.8 Summary and Concluding Remarks
537
10.9 Exercises
538
10.10 Explorations
542
10.11 Bibliographic Notes
543
I
I
Logic Languages
545
I I.
I
Logic Programming Concepts
546
11.2 Prolog
547
I 1.2.1 Resolution and Unification
549
I 1.2.2 Lists
550
Contents
xvii
I 1.2.3 Arithmetic
551
I 1.2.4 Search/Execution Order
552
I 1.2.5 Extended Example: Tic-Tac-Toe
554
I 1.2.6 Imperative Control Flow
557
I 1.2.7 Database Manipulation
561
I 1.3 Theoretical Foundations ©253
• 566
I 1.3.1 Clausal Form
©254
11.3.2 Limitations
©255
11.3.3 Skolemization
©257
11.4 Logic Programming in Perspective
566
I 1.4.1 Parts
of
Logic Not Covered
566
I 1.4.2 Execution Order
567
11.4.3 Negation and the "Closed World" Assumption
568
11.5 Summary and Concluding Remarks
570
I 1.6 Exercises
571
I 1.7 Explorations
573
I 1.8 Bibliographic Notes
573
12 Concurrency
575
12.1 Background and Motivation
576
12.1.1 The Case for Multithreaded Programs
579
12.1.2 Multiprocessor Architecture
581
12.2 Concurrent Programming Fundamentals
586
12.2.1 Communication and Synchronization
587
12.2.2 Languages and Libraries
588
12.2.3 Thread Creation Syntax
589
12.2.4 Implementation of Threads
598
12.3 Implementing Synchronization
603
12.3.1 Busy-Wait Synchronization
604
12.3.2 Nonblocking Algorithms
607
12.3.3 Memory Consistency Models
610
12.3.4 Scheduler Implementation
613
12.3.5 Semaphores
617
12.4 Language-Level Mechanisms
619
12.4.1 Monitors
619
12.4.2 Conditional Critical Regions
624
12.4.3 Synchronization in Java
626
xviii Content s
12.4.4 Transactional Memory
629
12.4.5 Implicit Synchronization
633
12.5 Message Passing ©263
• 637
12.5.1 Naming Communication Partners
©263
12.5.2 Sending
©267
12.5.3 Receiving
©272
12.5.4 Remote Procedure Call
©278
12.6 Summary and Concluding Remarks
638
12.7 Exercises
640
12.8 Explorations
645
12.9 Bibliographic Notes
647
13 Scripting Languages
649
13.1 What
Is a
Scripting Language?
650
13.1.1 Common Characteristics
652
13.2 Problem Domains
655
13.2.1 Shell (Command) Languages
655
13.2.2 Text Processing and Report Generation
663
I 3.2.3 Mathematics
and
Statistics
667
I 3.2.4 "Glue" Languages
and
General-Purpose Scripting
668
13.2.5 Extension Languages
676
13.3 Scripting
the
World Wide
Web
680
13.3.1
CGI
Scripts
680
13.3.2 Embedded Server-Side Scripts
681
13.3.3 Client-Side Scripts
686
13.3.4 Java Applets
686
13.3.5 XSLT ©287
• 689
13.4 Innovative Features
691
13.4.1 Names
and
Scopes
691
13.4.2 String
and
Pattern Manipulation
696
13.4.3 Data Types
704
13.4.4 Object Orientation
710
13.5 Summary and Concluding Remarks
717
13.6 Exercises
718
13.7 Explorations
723
13.8 Bibliographic Notes
724
Contents xix
A CLOSER LOOK AT IMPLEMENTATION
727
14 Building
a
Runnable Program
729
14.1 Back-End Compiler Structure
729
14.1.1
A
Plausible Set
of
Phases
730
14.1.2 Phases and Passes
734
14.2 Intermediate Forms ©303
• 734
14.2.1 Diana
©303
14.2.2 The gcc IFs
©306
14.2.3 Stack-Based Intermediate Forms
736
14.3 Code Generation
738
14.3.1 An Attribute Grammar Example
738
14.3.2 Register Allocation
741
14.4 Address Space Organization
744
14.5 Assembly
746
14.5.1 Emitting Instructions
748
14.5.2 Assigning Addresses to Names
749
14.6 Linking
750
14.6.1 Relocation and Name Resolution
751
14.6.2 Type Checking
751
14.7 Dynamic Linking
©311 -754
14.7.1 Position-Independent Code
©312
14.7.2 Fully Dynamic (Lazy) Linking
©313
14.8 Summary and Concluding Remarks
755
14.9 Exercises
756
14.10 Explorations
758
14.11 Bibliographic Notes
759
15 Run-time Program Management
761
15.1 Virtual Machines
764
15.1.1 The
Java
Virtual Machine
766
15.1.2 The Common Language Infrastructure
775
15.2 Late Binding of Machine Code
784
15.2.1 Just-in-Time and Dynamic Compilation
785
15.2.2 Binary Translation
791
XX Contents
15.2.3 Binary Rewritin g
15.2.4 Mobile Code and Sandboxin g
15.3 Inspection/Introspectio n
15.3.1 Reflectio n
15.3.2 Symbolic Debuggin g
15.3.3 Performance Analysi s
15.4 Summary and Concluding Remark s
15.5 Exercise s
15.6 Exploration s
15.7 Bibliographic Note s
16 Code Improvemen t
16.1 Phases of Code Improvemen t
16.2 Peephole Optimizatio n
16.3 Redundancy Elimination in Basic Block s
16.3.1 A Running Exampl e
16.3.2 Value Numberin g
16.4 Global Redundancy and Data Flow Analysi s
16.4.1 SSA Form and Global Value Numberin g
16.4.2 Global Common Subexpression Eliminatio n
16.5 Loop Improvement I
16.5.1 Loop Invariant s
16.5.2 Induction Variable s
16.6 Instruction Schedulin g
16.7 Loop Improvement I I
16.7.1 Loop Unrolling and Software Pipelinin g
16.7.2 Loop Reorderin g
16.8 Register Allocatio n
16.9 Summary and Concluding Remark s
16.10 Bibliographic Note s
A Programming Languages Mentione d
Ð’ Language Design and Language Implementatio n
С Numbered Example s
Bibliography
Index
... Next, we design an interactive debugger to help developers maintain code written in high-level languages for hardware accelerators. Debuggers are a vital part of a developer's arsenal of maintenance tools [190]. Although debugging support for CPUs is mature and fully featured (e.g., including standard tools [206], successful technology transfer [24] and annual conferences [1]), the throughput of automata processing applications on CPUs is typically orders of magnitude slower than execution on hardware accelerators [166,231] We develop a high-throughput, interactive debugger for the RAPID programming language. ...
... We focus on the implementation of two key debugging operations: setting breakpoints to stop program execution, and the inspection of program variables [190]. ...
... Parsers are typically implemented as the second stage of a larger pipeline [190]. ...
- Kevin Angstadt
The adoption of hardware accelerators, such as Field-Programmable Gate Arrays, into general-purpose computation pipelines continues to rise, driven by recent trends in data collection and analysis as well as pressure from challenging physical design constraints in hardware. The architectural designs of many of these accelerators stand in stark contrast to the traditional von Neumann model of CPUs. Consequently, existing programming languages, maintenance tools, and techniques are not directly applicable to these devices, meaning that additional architectural knowledge is required for effective programming and configuration. Current programming models and techniques are akin to assembly-level programming on a CPU, thus placing significant burden on developers tasked with using these architectures. Because programming is currently performed at such low levels of abstraction, the software development process is tedious and challenging and hinders the adoption of hardware accelerators. This dissertation explores the thesis that theoretical finite automata provide a suitable abstraction for bridging the gap between high-level programming models and maintenance tools familiar to developers and the low-level hardware representations that enable high-performance execution on hardware accelerators. We adopt a principled hardware/software co-design methodology to develop a programming model providing the key properties that we observe are necessary for success, namely performance and scalability, ease of use, expressive power, and legacy support. First, we develop a framework that allows developers to port existing, legacy code to run on hardware accelerators by leveraging automata learning algorithms in a novel composition with software verification, string solvers, and high-performance automata architectures. Next, we design a domain-specific programming language to aid programmers writing pattern-searching algorithms and develop compilation algorithms to produce finite automata, which supports efficient execution on a wide variety of processing architectures. Then, we develop an interactive debugger for our new language, which allows developers to accurately identify the locations of bugs in software while maintaining support for high-throughput data processing. Finally, we develop two new automata-derived accelerator architectures to support additional applications, including the detection of security attacks and the parsing of recursive and tree-structured data. Using empirical studies, logical reasoning, and statistical analyses, we demonstrate that our prototype artifacts scale to real-world applications, maintain manageable overheads, and support developers' use of hardware accelerators. Collectively, the research efforts detailed in this dissertation help ease the adoption and use of hardware accelerators for data analysis applications, while supporting high-performance computation.
... Analisis semantik adalah analisis untuk menemukan makna dari teks dengan menginterpretasikan keseluruhan teks, masing-masing kalimat, paragraf, struktur gramatika, hubungan antar kata dalam konteks tertentu, dan sebagainya (Scott, 2009). Dalam penelitian ini analisis semantik digunakan untuk menginterpretasikan dan mengklasifikasi kata-kata kunci berdasarkan rumpun makna tertentu. ...
- Hilary Relita Vertikasari Sekarningrum
-
![Gregorius Ari Nugrahanta]()
- Irine Kurniastuti
Tujuan penelitian ini adalah untuk mengembangkan modul permainan tradisional guna menumbuhkan karakter kontrol diri anak usia 6-8 tahun. Metode yang digunakan dalam penelitian ini adalah penelitian pengembangan (R & D) tipe ADDIE. Penelitian ini melibatkan enam guru dari berbagai daerah untuk analisis kebutuhan, tujuh validator untuk expert judgement, dan enam anak untuk uji coba modul secara terbatas. Hasil penelitian menunjukkan 1) Modul permainan tradisional untuk menumbuhkan karakter kontrol diri anak usia 6-8 tahun dikembangkan berdasarkan langkah-langkah dalam ADDIE, yaitu Analyze, Design, Develop, Implement, dan Evaluate; 2) Kualitas modul permainan tradisional secara keseluruhan adalah "sangat baik" dengan skor 3,98 (skala 1-4) dengan rekomendasi "Tidak perlu revisi"; dan 3) Penerapan modul permainan tradisional berpengaruh terhadap karakter kontrol diri anak. Hasil uji signifikansi menunjukkan t(5) = 3,929; p < 0,05. Besar pengaruh adalah r = 0,87 yang masuk kategori "efek besar" atau setara dengan 75,50%. Artinya, modul permainan tradisional dapat menjelaskan 75,50% perubahan varian pada karakter kontrol diri. Tingkat efektivitas ditunjukkan dengan N-gain score sebesar 66,07% yang masuk kategori "sedang".
... Programming language semantics A variety of programming language constructs have some relevance to intentional forgetting. For example, many programming languages define the lexical scope, or region of a program, in which a name binding to a program object is valid [27]. Outside that scope, the binding is forgotten (i.e., the name is forgotten). ...
- Deborah Shands
- Carolyn Talcott
Many damaging cybersecurity attacks are enabled when an attacker can access residual sensitive information (e.g. cryptographic keys, personal identifiers) left behind from earlier computation. Attackers can sometimes use residual information to take control of a system, impersonate a user, or manipulate data. Current approaches to addressing access to residual sensitive information aim to patch individual software or hardware vulnerabilities. While such patching approaches are necessary to mitigate sometimes serious security vulnerabilities in the near term, they cannot address the underlying issue: explicit requirements for adequately eliminating residual information and explicit representations of the erasure capabilities of systems are necessary to ensure that sensitive information is handled as expected. This position paper introduces the concept of intentional forgetting and the capabilities that are needed to achieve it. Intentional forgetting enables software and hardware system designers at every level of abstraction to clearly specify and rigorously reason about the forgetting capabilities required of and provided by a system. We identify related work that may help to illuminate challenges or contribute to solutions and consider conceptual and engineering tradeoffs in implementations of forgetting capabilities. We discuss approaches to modeling intentional forgetting and then modeling the strength of a system's forgetting capability by its resistance to disclosing information to different types of detectors. Research is needed in a variety of domains to advance the theory, specification techniques, system foundations, implementation tools, and methodologies for effective, practical forgetting. We highlight research challenges in several domains and encourage cross-disciplinary collaboration to one day create a robust theory and practice of intentional forgetting.
... The Yoruba-based PL was implemented as a sourceto-source compiler that produces another highlevel language, QBASIC language, as output because a compiler already exists for QBASIC. This approach has been used for a number of programming languages, such as Java, Python, and others [24]. The programming language was implemented in four phases, viz: lexical analysis, syntax analysis, semantic analysis and code generation. ...
p>Most of the existing high level programming languages havehitherto borrowed their lexical items from human languages including European and Asian languages. However, there is paucity of research information on programming languages developed with the lexicons of an African indigenous language. This research explored the design and implementation of an African indigenous language-based programming language using Yoruba as case study. Yoruba is the first language of over 30 million people in the south-west of Nigeria, Africa; and is spoken by over one hundred million people world-wide. It is hoped, as established by research studies, that making computer programming possible in one's mother tongue will enhance computer-based problem-solving processes by indigenous learners and teachers. The alphabets and reserved words of the programming language were respectively formed from the basic Yoruba alphabets and standard Yoruba words. The lexical items and syntactic structures of the programming language were designed with appropriate regular expressions and context-free grammars, using Backus-Naur Form (BNF) notations. A prototype implementation of the programming language was carried out as a source-to-source, 5-pass compiler. QBasic within QB64 IDE was the implementation language. The results from implementation showed functional correctness and effectiveness of the developed programming language. Thus lexical items of a programming language need not be borrowed exclusively from European and Asian languages, they can and should be borrowed from most African native languages. Furthermore, the developed native language programming language can be used to introduce computer programming to indigenous pupils of primary and junior secondary schools.</p
... A generator or iterator is a special kind of co-routine function which yields data elements one at a time, rather than many together as a collection; see, e.g. [14,Ch. 8]. ...
-
![Alexander Brandt]()
- Marc Moreno Maza
Hensel's lemma, combined with repeated applications of Weierstrass preparation theorem, allows for the factorization of polynomials with multivariate power series coefficients. We present a complexity analysis for this method and leverage those results to guide the load-balancing of a parallel implementation to concurrently update all factors. In particular, the factorization creates a pipeline where the terms of degree k of the first factor are computed simultaneously with the terms of degree k-1 of the second factor, etc. An implementation challenge is the inherent irregularity of computational work between factors, as our complexity analysis reveals. Additional resource utilization and load-balancing is achieved through the parallelization of Weierstrass preparation. Experimental results show the efficacy of this mixed parallel scheme, achieving up to 9x speedup on 12 cores.
... Example implementations of complex patterns, such as upstream process synchronization, exclusive choice among downstream processes, and feedback loops, are available in the documentation (Tommaso et al., 2019). Like Swift/T, Nextflow treats functions as first class objects (Scott, 2009) that can be used in the same ways as variables, enabling the programmer to create easily extensible pipelines, which is a very important feature in the world of ever-changing bioinformatics analyses. CWL and WDL are qualitatively different. ...
Background: The changing landscape of genomics research and clinical practice has created a need for computational pipelines capable of efficiently orchestrating complex analysis stages while handling large volumes of data across heterogeneous computational environments. Workflow Management Systems (WfMSs) are the software components employed to fill this gap. Results: This work provides an approach and systematic evaluation of key features of popular bioinformatics WfMSs in use today: Nextflow, CWL, and WDL and some of their executors, along with Swift/T, a workflow manager commonly used in high-scale physics applications. We employed two use cases: a variant-calling genomic pipeline and a scalability-testing framework, where both were run locally, on an HPC cluster, and in the cloud. This allowed for evaluation of those four WfMSs in terms of language expressiveness, modularity, scalability, robustness, reproducibility, interoperability, ease of development, along with adoption and usage in research labs and healthcare settings. This article is trying to answer, "which WfMS should be chosen for a given bioinformatics application regardless of analysis type?". Conclusions: The choice of a given WfMS is a function of both its intrinsic language and engine features. Within bioinformatics, where analysts are a mix of dry and wet lab scientists, the choice is also governed by collaborations and adoption within large consortia and technical support provided by the WfMS team/community. As the community and its needs continue to evolve along with computational infrastructure, WfMSs will also evolve, especially those with permissive licenses that allow commercial use. In much the same way as the dataflow paradigm and containerization are now well understood to be very useful in bioinformatics applications, we will continue to see innovations of tools and utilities for other purposes, like big data technologies, interoperability, and provenance.
High-throughput image-based technologies are now widely used in the rapidly developing field of digital phenomics and are generating ever-increasing amounts and diversity of data. Artificial intelligence (AI) is becoming a game changer in turning the vast seas of data into valuable predictions and insights. However, this requires specialized programming skills and an in-depth understanding of machine learning, deep learning, and ensemble learning algorithms. Here, we attempt to methodically review the usage of different tools, technologies, and services available to the phenomics data community and show how they can be applied to selected problems in explainable AI-based image analysis. This tutorial provides practical and useful resources for novices and experts to harness the potential of the phenomic data in explainable AI-led breeding programs.
Hensel's lemma, combined with repeated applications of Weierstrass preparation theorem, allows for the factorization of polynomials with multivariate power series coefficients. We present a complexity analysis for this method and leverage those results to guide the load-balancing of a parallel implementation to concurrently update all factors. In particular, the factorization creates a pipeline where the terms of degree k of the first factor are computed simultaneously with the terms of degree \(k-1\) of the second factor, etc. An implementation challenge is the inherent irregularity of computational work between factors, as our complexity analysis reveals. Additional resource utilization and load-balancing is achieved through the parallelization of Weierstrass preparation. Experimental results show the efficacy of this mixed parallel scheme, achieving up to 9\(\times \) parallel speedup on a 12-core machine.
Object-oriented programming (OOP) is one of the most common programming paradigms used for building software systems. However, despite its industrial and academic value, OOP is criticized for its high complexity, low maintainability and lack of rigorous principles. Eolang (a.k.a. EO) was created to solve the above problems by restricting its features and suggesting a formal object calculus for this programming language. This paper seeks to analyze the Eolang language and compare it to other OOP languages in order to develop the core features of this new language.
ResearchGate has not been able to resolve any references for this publication.
Posted by: karisasnarre0194815.blogspot.com
Source: https://www.researchgate.net/publication/220695725_Programming_language_pragmatics_2_ed
