- Table View
- List View
Concise Guide to Computation Theory
by Akira MaruokaThis textbook presents a thorough foundation to the theory of computation. Combining intuitive descriptions and illustrations with rigorous arguments and detailed proofs for key topics, the logically structured discussion guides the reader through the core concepts of automata and languages, computability, and complexity of computation. Topics and features: presents a detailed introduction to the theory of computation, complete with concise explanations of the mathematical prerequisites; provides end-of-chapter problems with solutions, in addition to chapter-opening summaries and numerous examples and definitions throughout the text; draws upon the author's extensive teaching experience and broad research interests; discusses finite automata, context-free languages, and pushdown automata; examines the concept, universality and limitations of the Turing machine; investigates computational complexity based on Turing machines and Boolean circuits, as well as the notion of NP-completeness.
Concise Guide to Computing Foundations: Core Concepts and Select Scientific Applications
by Kevin Brewer Cathy BareissThis book will help future scientists to become more intelligent users of computing technology in their practice of science. The content is suitable for introductory courses on the foundations of computing and the specific application of computers in different areas of science. The text presents a set of modules for use in existing science courses in order to integrate individual aspects of computational thinking, as well as a set of modules introducing the computer science concepts needed to understand the computing involved. These modules guide science students in their independent learning. The book covers computing applications in such diverse areas as bioinformatics, cladistics, chemical kinetics, molecular modeling, geographic information systems, flow analysis, the solving of equations, curve fitting, optimization, and scientific data acquisition. The computing topics covered include simulations, errors, data representation, algorithms, XMS, compression, databases, performance, and complexity.
Concise Guide to Databases: A Practical Introduction (Undergraduate Topics in Computer Science)
by Paul Crowther Peter LakeThis easy-to-read textbook/reference presents a comprehensive introduction to databases, opening with a concise history of databases and of data as an organisational asset. As relational database management systems are no longer the only database solution, the book takes a wider view of database technology, encompassing big data, NoSQL, object and object-relational and in-memory databases. The text also examines the issues of scalability, availability, performance and security encountered when building and running a database in the real world. Topics and features: presents review and discussion questions at the end of each chapter, in addition to skill-building, hands-on exercises; introduces the fundamental concepts and technologies in database systems, placing these in an historic context; describes the challenges faced by database professionals; reviews the use of a variety of database types in business environments; discusses areas for further research within this fast-moving domain.
Concise Guide to Formal Methods
by Gerard O'ReganThis invaluable textbook/reference provides an easy-to-read guide to the fundamentals of formal methods, highlighting the rich applications of formal methods across a diverse range of areas of computing.Topics and features: introduces the key concepts in software engineering, software reliability and dependability, formal methods, and discrete mathematics; presents a short history of logic, from Aristotle’s syllogistic logic and the logic of the Stoics, through Boole’s symbolic logic, to Frege’s work on predicate logic; covers propositional and predicate logic, as well as more advanced topics such as fuzzy logic, temporal logic, intuitionistic logic, undefined values, and the applications of logic to AI; examines the Z specification language, the Vienna Development Method (VDM) and Irish School of VDM, and the unified modelling language (UML); discusses Dijkstra’s calculus of weakest preconditions, Hoare’s axiomatic semantics of programming languages, and the classical approach of Parnas and his tabular expressions; provides coverage of automata theory, probability and statistics, model checking, and the nature of proof and theorem proving; reviews a selection of tools available to support the formal methodist, and considers the transfer of formal methods to industry; includes review questions and highlights key topics in every chapter, and supplies a helpful glossary at the end of the book.This stimulating guide provides a broad and accessible overview of formal methods for students of computer science and mathematics curious as to how formal methods are applied to the field of computing.
Concise Guide to Numerical Algorithmics: The Foundations and Spirit of Scientific Computing (SpringerBriefs in Computer Science)
by John Lawrence NazarethNumerical Algorithmic Science and Engineering (NAS&E), or more compactly, Numerical Algorithmics, is the theoretical and empirical study and the practical implementation and application of algorithms for solving finite-dimensional problems of a numeric nature. The variables of such problems are either discrete-valued, or continuous over the reals, or, and as is often the case, a combination of the two, and they may or may not have an underlying network/graph structure. This re-emerging discipline of numerical algorithmics within computer science is the counterpart of the now well-established discipline of numerical analysis within mathematics, where the latter’s emphasis is on infinite-dimensional, continuous numerical problems and their finite-dimensional, continuous approximates. A discussion of the underlying rationale for numerical algorithmics, its foundational models of computation, its organizational details, and its role, in conjunction with numerical analysis, in support of the modern modus operandi of scientific computing, or computational science & engineering, is the primary focus of this short monograph. It comprises six chapters, each with its own bibliography. Chapters 2, 3 and 6 present the book’s primary content. Chapters 1, 4, and 5 are briefer, and they provide contextual material for the three primary chapters and smooth the transition between them. Mathematical formalism has been kept to a minimum, and, whenever possible, visual and verbal forms of presentation are employed and the discussion enlivened through the use of motivating quotations and illustrative examples. The reader is expected to have a working knowledge of the basics of computer science, an exposure to basic linear algebra and calculus (and perhaps some real analysis), and an understanding of elementary mathematical concepts such as convexity of sets and functions, networks and graphs, and so on. Although this book is not suitable for use as the principal textbook for a course on numerical algorithmics (NAS&E), it will be of value as a supplementary reference for a variety of courses. It can also serve as the primary text for a research seminar. And it can be recommended for self-study of the foundations and organization of NAS&E to graduate and advanced undergraduate students with sufficient mathematical maturity and a background in computing. When departments of computer science were first created within universities worldwide during the middle of the twentieth century, numerical analysis was an important part of the curriculum. Its role within the discipline of computer science has greatly diminished over time, if not vanished altogether, and specialists in that area are now to be found mainly within other fields, in particular, mathematics and the physical sciences. A central concern of this monograph is the regrettable, downward trajectory of numerical analysis within computer science and how it can be arrested and suitably reconstituted. Resorting to a biblical metaphor, numerical algorithmics (NAS&E) as envisioned herein is neither old wine in new bottles, nor new wine in old bottles, but rather this re-emerging discipline is a decantation of an age-old vintage that can hopefully find its proper place within the larger arena of computer science, and at what appears now to be an opportune time.
Concise Guide to Optimization Models and Methods: A Problem-Based Test Prep for Students
by Xian Wen NgThis concise text contains the most commonly-encountered examination problems in the topic of Optimization Models and Methods, an important module in engineering and other disciplines where there exists an increasing need to operate optimally and sustainably under constraints, such as tighter resource availability, environmental consideration, and cost pressures. This book is comprehensive in coverage as it includes a diverse spectrum of problems from numerical open-ended questions that probe creative thinking to the relation of concepts to realistic settings. The book adopts many examples of design scenarios as context for curating sample problems. This will help students relate desktop problem-solving to tackling real-world problems. Succinct yet rigorous, with over a 100 pages of problems and corresponding worked solutions presented in detail, the book is ideal for students of engineering, applied science, and market analysis.
Concise Guide to Quantum Computing: Algorithms, Exercises, and Implementations (Texts in Computer Science)
by Sergei Kurgalin Sergei BorzunovThis textbook is intended for practical, laboratory sessions associated with the course of quantum computing and quantum algorithms, as well as for self-study. It contains basic theoretical concepts and methods for solving basic types of problems and gives an overview of basic qubit operations, entangled states, quantum circuits, implementing functions, quantum Fourier transform, phase estimation, etc. The book serves as a basis for the application of new information technologies in education and corporate technical training: theoretical material and examples of practical problems, as well as exercises with, in most cases, detailed solutions, have relation to information technologies. A large number of detailed examples serve to better develop professional competencies in computer science.
Concise Guide to Software Engineering
by Gerard O'ReganThis essential textbook presents a concise introduction to the fundamental principles of software engineering, together with practical guidance on how to apply the theory in a real-world, industrial environment. The wide-ranging coverage encompasses all areas of software design, management, and quality.Topics and features: presents a broad overview of software engineering, including software lifecycles and phases in software development, and project management for software engineering; examines the areas of requirements engineering, software configuration management, software inspections, software testing, software quality assurance, and process quality; covers topics on software metrics and problem solving, software reliability and dependability, and software design and development, including Agile approaches; explains formal methods, a set of mathematical techniques to specify and derive a program from its specification, introducing the Z specification language; discusses software process improvement, describing the CMMI model, and introduces UML, a visual modelling language for software systems; reviews a range of tools to support various activities in software engineering, and offers advice on the selection and management of a software supplier; describes such innovations in the field of software as distributed systems, service-oriented architecture, software as a service, cloud computing, and embedded systems; includes key learning topics, summaries and review questions in each chapter, together with a useful glossary.This practical and easy-to-follow textbook/reference is ideal for computer science students seeking to learn how to build high quality and reliable software on time and on budget. The text also serves as a self-study primer for software engineers, quality professionals, and software managers.
Concise Guide to Software Engineering: From Fundamentals to Application Methods (Undergraduate Topics in Computer Science)
by Gerard O'ReganThis textbook presents a concise introduction to the fundamental principles of software engineering, together with practical guidance on how to apply the theory in a real-world, industrial environment. The wide-ranging coverage encompasses all areas of software design, management, and quality.Topics and features: presents a broad overview of software engineering, including software lifecycles and phases in software development, and project management for software engineering; examines the areas of requirements engineering, software configuration management, software inspections, software testing, software quality assurance, and process quality; covers topics on software metrics and problem solving, software reliability and dependability, and software design and development, including Agile approaches; explains formal methods, a set of mathematical techniques to specify and derive a program from its specification, introducing the Z specification language; discusses software process improvement, describing the CMMI model, and introduces UML, a visual modelling language for software systems; reviews a range of tools to support various activities in software engineering, and offers advice on the selection and management of a software supplier; describes such innovations in the field of software as distributed systems, service-oriented architecture, software as a service, cloud computing, and embedded systems; includes key learning topics, summaries and review questions in each chapter, together with a useful glossary.This practical and easy-to-follow textbook/reference is ideal for computer science students seeking to learn how to build high quality and reliable software on time and on budget. The text also serves as a self-study primer for software engineers, quality professionals, and software managers.
Concise Guide to Software Testing (Undergraduate Topics in Computer Science)
by Gerard O'ReganThis practically-focused textbook provides a concise and accessible introduction to the field of software testing, explaining the fundamental principles and offering guidance on applying the theory in an industrial environment.Topics and features: presents a brief history of software quality and its influential pioneers, as well as a discussion of the various software lifecycles used in software development; describes the fundamentals of testing in traditional software engineering, and the role that static testing plays in building quality into a product; explains the process of software test planning, test analysis and design, and test management; discusses test outsourcing, and test metrics and problem solving; reviews the tools available to support software testing activities, and the benefits of a software process improvement initiative; examines testing in the Agile world, and the verification of safety critical systems; considers the legal and ethical aspects of software testing, and the importance of software configuration management; provides key learning topics and review questions in every chapter, and supplies a helpful glossary at the end of the book.This easy-to-follow guide is an essential resource for undergraduate students of computer science seeking to learn about software testing, and how to build high quality and reliable software on time and on budget. The work will also be of interest to industrialists including software engineers, software testers, quality professionals and software managers, as well as the motivated general reader.
Concise Guide to Software Verification: From Model Checking to Annotation Checking (Texts in Computer Science)
by Anton Wijs Marieke HuismanThis textbook overviews the whole spectrum of formal methods and techniques that are aimed at verifying correctness of software, and how they can be used in practice. It focuses on techniques whereby the user has some control over the properties that are being checked. More specifically, it shows a wide range of techniques covering the whole spectrum: from abstract system design to implementation, from bug finding to full proofs, and from techniques that are push-button by design and give a yes/no answer to techniques that require the user to provide explicit guidance to steer the analysis process.Topics and features:Covers a broad spectrum of software verification techniques, from model checking to annotation checkingProvides numerous examples to demonstrate the techniquesFocuses on how techniques can be used (and the main ideas behind how they work), as opposed to how they are implementedExplains strengths and weaknesses of the techniques, providing insight into when to use which technique in practiceThis unique textbook has been written primarily for master’s level students in computer science studying embedded systems and specializing in software technology. The book will also be of interest for students studying cyber security and data science technology, as well as for system or software developers interested in techniques that offer formal guarantees about software.
Concrete Abstractions: Formalizing and Analyzing Discrete Theories and Algorithms with the RISCAL Model Checker (Texts & Monographs in Symbolic Computation)
by Wolfgang SchreinerThis book demonstrates how to formally model various mathematical domains (including algorithms operating in these domains) in a way that makes them amenable to a fully automatic analysis by computer software.The presented domains are typically investigated in discrete mathematics, logic, algebra, and computer science; they are modeled in a formal language based on first-order logic which is sufficiently rich to express the core entities in whose correctness we are interested: mathematical theorems and algorithmic specifications. This formal language is the language of RISCAL, a “mathematical model checker” by which the validity of all formulas and the correctness of all algorithms can be automatically decided. The RISCAL software is freely available; all formal contents presented in the book are given in the form of specification files by which the reader may interact with the software while studying the corresponding book material.
Concurrency Control in Distributed System Using Mutual Exclusion (Studies in Systems, Decision and Control #116)
by Nabendu Chaki Sukhendu Kanrar Samiran ChattopadhyayThe book presents various state-of-the-art approaches for process synchronization in a distributed environment. The range of algorithms discussed in the book starts from token based mutual exclusion algorithms that work on tree based topology. Then there are interesting solutions for more flexible logical topology like a directed graph, with or without cycle. In a completely different approach, one of the chapters presents two recent voting-based DME algorithms. All DME algorithms presented in the book aim to ensure fairness in terms of first come first serve (FCFS) order among equal priority processes. At the same time, the solutions consider the priority of the requesting processes and allocate resource for the earliest request when no such request from a higher priority process is pending.
Concurrency in .NET: Modern patterns of concurrent and parallel programming
by Riccardo TerrellSummaryConcurrency in .NET teaches you how to build concurrent and scalable programs in .NET using the functional paradigm. This intermediate-level guide is aimed at developers, architects, and passionate computer programmers who are interested in writing code with improved speed and effectiveness by adopting a declarative and pain-free programming style.Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.About the TechnologyUnlock the incredible performance built into your multi-processor machines. Concurrent applications run faster because they spread work across processor cores, performing several tasks at the same time. Modern tools and techniques on the .NET platform, including parallel LINQ, functional programming, asynchronous programming, and the Task Parallel Library, offer powerful alternatives to traditional thread-based concurrency.About the BookConcurrency in .NET teaches you to write code that delivers the speed you need for performance-sensitive applications. Featuring examples in both C# and F#, this book guides you through concurrent and parallel designs that emphasize functional programming in theory and practice. You'll start with the foundations of concurrency and master essential techniques and design practices to optimize code running on modern multiprocessor systems. What's InsideThe most important concurrency abstractionsEmploying the agent programming model Implementing real-time event-stream processing Executing unbounded asynchronous operationsBest concurrent practices and patterns that apply to all platformsAbout the ReaderFor readers skilled with C# or F#.About the BookRiccardo Terrell is a seasoned software engineer and Microsoft MVP who is passionate about functional programming. He has over 20 years' experience delivering cost-effective technology solutions in a competitive business environment.Table of ContentsPART 1 - Benefits of functional programming applicable to concurrent programs Functional concurrency foundationsFunctional programming techniques for concurrencyFunctional data structures and immutabilityPART 2 - How to approach the different parts of a concurrent programThe basics of processing big data: data parallelism, part 1PLINQ and MapReduce: data parallelism, part 2Real-time event streams: functional reactive programmingTask-based functional parallelismTask asynchronicity for the winAsynchronous functional programming in F#Functional combinators for fluent concurrent programmingApplying reactive programming everywhere with agentsParallel workflow and agent programming with TPL DataflowPART 3 - Modern patterns of concurrent programming appliedRecipes and design patterns for successful concurrent programmingBuilding a scalable mobile app with concurrent functional programming
Concurrency in C# Cookbook
by Stephen ClearyIf you're one of the many developers uncertain about concurrent and multithreaded development, this practical cookbook will change your mind. With more than 75 code-rich recipes, author Stephen Cleary demonstrates parallel processing and asynchronous programming techniques, using libraries and language features in .NET 4.5 and C# 5.0.Concurrency is becoming more common in responsive and scalable application development, but it's been extremely difficult to code. The detailed solutions in this cookbook show you how modern tools raise the level of abstraction, making concurrency much easier than before. Complete with ready-to-use code and discussions about how and why the solution works, you get recipes for using:async and await for asynchronous operationsParallel programming with the Task Parallel LibraryThe TPL Dataflow library for creating dataflow pipelinesCapabilities that Reactive Extensions build on top of LINQUnit testing with concurrent codeInterop scenarios for combining concurrent approachesImmutable, threadsafe, and producer/consumer collectionsCancellation support in your concurrent codeAsynchronous-friendly Object-Oriented ProgrammingThread synchronization for accessing data
Concurrency in C# Cookbook: Asynchronous, Parallel, and Multithreaded Programming
by Stephen ClearyIf you’re one of many developers still uncertain about concurrent and multithreaded development, this practical cookbook will change your mind. With more than 85 code-rich recipes in this updated second edition, author Stephen Cleary demonstrates parallel processing and asynchronous programming techniques using libraries and language features in .NET and C# 8.0.Concurrency is now more common in responsive and scalable application development, but it’s still extremely difficult to code. The detailed solutions in this cookbook show you how modern tools raise the level of abstraction, making concurrency much easier than before. Complete with ready-to-use code and discussions about how and why solutions work, these recipes help you:Get up to speed on concurrency and async and parallel programmingUse async and await for asynchronous operationsEnhance your code with asynchronous streamsExplore parallel programming with .NET’s Task Parallel LibraryCreate dataflow pipelines with .NET’s TPL Dataflow libraryUnderstand the capabilities that System.Reactive builds on top of LINQUtilize threadsafe and immutable collectionsLearn how to conduct unit testing with concurrent codeMake the thread pool work for youEnable clean, cooperative cancellationExamine scenarios for combining concurrent approachesDive into asynchronous-friendly object-oriented programmingRecognize and write adapters for code using older asynchronous styles
Concurrency in Go: Tools and Techniques for Developers
by Katherine Cox-BudayConcurrency can be notoriously difficult to get right, but fortunately, the Go open source programming language makes working with concurrency tractable and even easy. If you’re a developer familiar with Go, this practical book demonstrates best practices and patterns to help you incorporate concurrency into your systems.Author Katherine Cox-Buday takes you step-by-step through the process. You’ll understand how Go chooses to model concurrency, what issues arise from this model, and how you can compose primitives within this model to solve problems. Learn the skills and tooling you need to confidently write and implement concurrent systems of any size.Understand how Go addresses fundamental problems that make concurrency difficult to do correctlyLearn the key differences between concurrency and parallelismDig into the syntax of Go’s memory synchronization primitivesForm patterns with these primitives to write maintainable concurrent codeCompose patterns into a series of practices that enable you to write large, distributed systems that scaleLearn the sophistication behind goroutines and how Go’s runtime stitches everything together
Concurrency, Security, and Puzzles: Essays Dedicated to Andrew William Roscoe on the Occasion of His 60th Birthday (Lecture Notes in Computer Science #10160)
by Thomas Gibson-Robinson Philippa Hopcroft Ranko LazićThis festschrift was written in honor of Andrew William (Bill) Roscoe on the occasion of his 60th birthday, and features tributes by Sir Tony Hoare, Stephen Brookes, and Michael Wooldridge. Bill Roscoe is an international authority in process algebra, and has been the driving force behind the development of the FDR refinement checker for CSP. He is also world renowned for his pioneering work in analyzing security protocols, modeling information flow, human-interactive security, and much more. Many of these areas are reflected in the 15 invited research articles in this festschrift, and in the presentations at the "BILL-60" symposium held in Oxford, UK, on January 9 and 10, 2017.
Concurrency, Specification and Programming: Revised Selected Papers from the 29th International Workshop on Concurrency, Specification and Programming (CS&P'21), Berlin, Germany (Studies in Computational Intelligence #1091)
by Thomas Vogel Andrzej Skowron Bernd-Holger SchlingloffThis book presents novel approaches to the formal specification of concurrent and parallel systems, mathematical models for describing such systems, and programming and verification concepts for their implementation. A special emphasis is on methods based on artificial intelligence and machine learning techniques.Chapters are revised selected papers from the 29th International Workshop on Concurrency, Specification, and Programming (CS&P 2021), Berlin, Germany. Nine independent chapters cover formal approaches to topics such as requirements formalization, parsing, or granular computing, as well as their applications in recommender systems, decision making, security, optimization, and other areas. The book thus addresses both researchers and practitioners in its field.
Concurrent Patterns and Best Practices: Build scalable apps with patterns in multithreading, synchronization, and functional programming
by Atul S. KhotA definitive guide to mastering and implementing concurrency patterns in your applicationsKey FeaturesBuild scalable apps with patterns in multithreading, synchronization, and functional programmingExplore the parallel programming and multithreading techniques to make the code run fasterEfficiently use the techniques outlined to build reliable applicationsBook DescriptionSelecting the correct concurrency architecture has a significant impact on the design and performance of your applications. This book explains how to leverage the different characteristics of parallel architecture to make your code faster and more efficient. To start with, you'll understand the basic concurrency concepts and explore patterns around explicit locking, lock free programming, futures & actors. Then, you'll get insights into different concurrency models and parallel algorithms and put them to practice in different scenarios to realize your application's true potential. We'll take you through multithreading design patterns, such as master, slave, leader, follower, map-reduce, and monitor, also helping you to learn hands-on coding using these patterns. Once you've grasped all of this, you'll move on to solving problems using synchronizer patterns. You'll discover the rationale for these patterns in distributed & parallel applications, followed by studying how future composition, immutability and the monadic flow help create more robust code. Toward the end of the book, you'll learn about the actor paradigm and actor patterns - the message passing concurrency paradigm.What you will learnExplore parallel architecture Get acquainted with concurrency models Internalize design themes by implementing multithreading patterns Get insights into concurrent design patterns Discover design principles behind many java threading abstractions Work with functional concurrency patternsWho this book is forThis is a must-have guide for developers who want to learn patterns to build scalable and high-performing apps. It’s assumed that you already have a decent level of programming knowledge.
Concurrent Programming Interviews: A Practical Guide to Becoming the Standout Candidate (Apress Pocket Guides)
by Bonan LiuAce your software engineering job interviews by preparing yourself for the concurrent programming rounds. This book fills the gap in practical resources designated for concurrency interview prep. It simplifies complex concepts in C++ and provides example questions to help you approach your interview with confidence. Today, interviews for software engineering roles typically include several different rounds: coding, system design, behavioral, and domain knowledge. The domain knowledge round can vary based on the job description, but one extremely common focus is concurrent programming. While not intended to be a comprehensive reference, this book distills the essential interview insights drawn from author Bonan Liu’s personal experiences to stand out from the competition. Key topics include mutexes and locks, condition variables, thread abstraction, STL features, and lock-free implementations, with each concept reinforced through practical exercises like building a file handler cache and implementing read/write locks. Software interviews are more than just exams; they are hours-long conversations with real people. You'll not only develop a solid understanding of concurrency, but also learn how to best showcase your expertise to enhance your performance throughout the entire process, including general coding rounds. What You Will Learn Acquire foundational knowledge of concurrent programming in C++. Practice relevant interview questions for each section of this knowledge. Develop strategies for best demonstrating learned skills in the general coding round. Who This Book Is For Software engineers seeking new career opportunities, particularly SDE II, Senior SDE, and Staff SDE roles. Interviewers might also gain insight into concurrent programming to enhance the evaluation of their candidates, securing top talent.
Concurrent Programming in Mac OS X and iOS: Unleash Multicore Performance with Grand Central Dispatch (Oreilly And Associate Ser.)
by Vandad NahavandipoorNow that multicore processors are coming to mobile devices, wouldn't it be great to take advantage of all those cores without having to manage threads? This concise book shows you how to use Apple's Grand Central Dispatch (GCD) to simplify programming on multicore iOS devices and Mac OS X.Managing your application’s resources on more than one core isn't easy, but it's vital. Apps that use only one core in a multicore environment will slow to a crawl. If you know how to program with Cocoa or Cocoa Touch, this guide will get you started with GCD right away, with many examples to help you write high-performing multithreaded apps.Package your code as block objects and invoke them with GCDUnderstand dispatch queues—the pools of threads managed by GCDUse different methods for executing UI and non-UI tasksCreate a group of tasks that GCD can run all at onceInstruct GCD to execute tasks only once or after a delayDiscover how to construct your own dispatch queues
Concurrent Programming: Algorithms, Principles, And Foundations
by Michel RaynalThe advent of new architectures and computing platforms means that synchronization and concurrent computing are among the most important topics in computing science. Concurrent programs are made up of cooperating entities -- processors, processes, agents, peers, sensors -- and synchronization is the set of concepts, rules and mechanisms that allow them to coordinate their local computations in order to realize a common task. This book is devoted to the most difficult part of concurrent programming, namely synchronization concepts, techniques and principles when the cooperating entities are asynchronous, communicate through a shared memory, and may experience failures. Synchronization is no longer a set of tricks but, due to research results in recent decades, it relies today on sane scientific foundations as explained in this book. In this book the author explains synchronization and the implementation of concurrent objects, presenting in a uniform and comprehensive way the major theoretical and practical results of the past 30 years. Among the key features of the book are a new look at lock-based synchronization (mutual exclusion, semaphores, monitors, path expressions); an introduction to the atomicity consistency criterion and its properties and a specific chapter on transactional memory; an introduction to mutex-freedom and associated progress conditions such as obstruction-freedom and wait-freedom; a presentation of Lamport's hierarchy of safe, regular and atomic registers and associated wait-free constructions; a description of numerous wait-free constructions of concurrent objects (queues, stacks, weak counters, snapshot objects, renaming objects, etc.); a presentation of the computability power of concurrent objects including the notions of universal construction, consensus number and the associated Herlihy's hierarchy; and a survey of failure detector-based constructions of consensus objects. The book is suitable for advanced undergraduate students and graduate students in computer science or computer engineering, graduate students in mathematics interested in the foundations of process synchronization, and practitioners and engineers who need to produce correct concurrent software. The reader should have a basic knowledge of algorithms and operating systems.
Concurrent, Real-Time and Distributed Programming in Java: Threads, RTSJ and RMI
by Badr BenmammarThis book provides an introduction to concurrent, real-time, distributed programming with Java object-oriented language support as an algorithm description tool. It describes in particular the mechanisms of synchronization (cooperative and competitive) and sharing of data (internal class, static variables) between threads in Java. He then discusses the use of Java for real-time applications. Consequently, a presentation of the RTSJ (Real Time Specification for Java) specification dedicated to the development of real-time applications in Java is also introduced in this book. Finally, a presentation of programming distributed in Java is presented in this book. We are particularly interested in communication using the TCP Sockets and high-level communication using Java Remote Method Invocation (RMI). The book also contains an annex which contains a practical set of application exercises in relation to the theme of the book. Knowledge of the Java language is a prerequisite for understanding the book.
Condition Monitoring Using Computational Intelligence Methods: Applications in Mechanical and Electrical Systems
by Tshilidzi MarwalaCondition Monitoring Using Computational Intelligence Methods promotes the various approaches gathered under the umbrella of computational intelligence to show how condition monitoring can be used to avoid equipment failures and lengthen its useful life, minimize downtime and reduce maintenance costs. The text introduces various signal-processing and pre-processing techniques, wavelets and principal component analysis, for example, together with their uses in condition monitoring and details the development of effective feature extraction techniques classified into frequency-, time-frequency- and time-domain analysis. Data generated by these techniques can then be used for condition classification employing tools such as: * fuzzy systems; rough and neuro-rough sets; neural and Bayesian networks;hidden Markov and Gaussian mixture models; and support vector machines.