You are Here:Home > computerscience
# Computer Science

This note describes the following topics: Parallel computer models, Program and Network properties, Processors and memory hierarchy, Bus, cache and shared memory, Pipelining and Superscalar Techniques, Multiprocessor and Multicomputers.

This lecture note covers the following topics: Parallel computer models, Program and Network properties, Pipelining, Cache memory Organization, Multithread and Data flow architecture, Concurrent Processor.

This book covers the following topics: Introduction to the SPARC Architecture, Assembling and Debugging, Control Transfer Instructions, Logical and Arithmetic Operations, Data Types and Addressing, Subroutines and Parameter Passing, Instruction Encoding.

This note covers the following topics: Basics of computer architecture, Introduction to Digital Electronics, Binary Numbers, Boolean Algebra, Combinational Logic Circuits, Sequential Logic Circuits, Von Neumann Architecture, Optimizing Hardware Performance, Low-level programming, Programming in C, Character encodings, Assembly programming.

This note discusses the computer hardware, software and their interconnection, and it also discusses concepts like computer types, evolution of computers, functional units, basic operations, RISC and CISC systems. Topics covered includes: Evolution of Computer Systems, Computer Types, Functional units, Basic operational concepts, Bus structures, Memory location and addresses, Memory operations, Addressing modes, Design of a computer system, Instruction and instruction sequencing, RISC versus CISC.

This note covers the following topics: History Of Compuers, Machine Instruction Set, Instruction Pipelining, Processor Control Unit, Microprogrammed Control Unit.

This book explains the following topics: Scope of Artificial Intelligence, Problem Solving, Knowledge Representation, Rule Based Systems, Structured Knowledge Representation, Handling Uncertainty and Learning, Expert Systems.

This book explains the theory of neural networks and provides illustrative examples in C++ that the reader can use as a basis for further experimentation.

This book is for both professional programmers and home hobbyists who already know how to program in Java and who want to learn practical Artificial Intelligence (AI) programming and information processing techniques. Topics covered includes: Search, Reasoning, Semantic Web, Expert Systems, Genetic Algorithms, Neural Networks, Machine Learning with Weka, Statistical Natural Language Processing.

This book covers the following topics related to Compiler Design: Lexical Analysis, Syntax Analysis, Interpretation, Type Checking, Intermediate-Code Generation, Machine-Code Generation, Register Allocation, Function calls, Analysis and optimisation, Memory management and Bootstrapping a compiler.

This note covers the following topics: Introduction, lexical analysis, LL parsing, LR parsing, JavaCC and JTB, Semantic analysis, Translation and simplification, Liveness analysis and register allocation, Activation Records.

This note explains the following topics: Lexical Analysis, Syntax Analysis, Semantic Analysis, Synthesized Attributes, Inherited Attributes, Abstract Syntax Trees, Symbol Tables, Intermediate Representation, Runtime Structure.

This lecture note explains the following topics: Language Processing System, Lexical Analysis, Syntax Analysis, Lr Parser, Canonical Lr Parsing, Semantic Analysis, Intermediate Code and Optimization.

This lecture note explains the following topics: Introduction to Compiling, A Simple One-Pass Compiler, Lexical Analysis, Syntax Analysis, Syntax-Directed Translation, Type Checking, Run-Time Environments, Intermediate Code Generation, Code generation, Code Optimization.

This note explains the following topics: Lexical Analysis, Parsing, Error Recovery, Intermediate Code Generation, Run Time Memory Management, Code optimization, Code Generation.

This book covers the following topics: Lexical Analysis, Bottom-Up Parsing and Yacc, Abstract Syntax Trees in C, Semantic Analysis in C, Generating Abstract Assembly in C and Code Generation.

This note covers the following topics: Parser, scanner, Optimization, Virtual Machines, Code Generation, Peephole Optimization.

This book covers the following topics related to Compiler Construction: Language and Syntax, Regular Languages, Attributed Grammars and Semantics, The Programming Language Oberon-0, A Parser for Oberon-0, Consideration of Context Specified by Declarations, A RISC Architecture as Target, Conditional and Repeated Statements and Boolean Epressions, Elementary Data Types, Open Arrays, Pointers and Procedure Types, Modules and Separate Compilation, Code Optimizations and the Frontend or backend Structure.

This book attempts to explain and demystify the principles of compiler writing. There is enough detail in this book to build a compiler for quite a complicated language certainly PASCAL, perhaps ALGOL 68 or SIMULA 67, but it doesn't attempt an encyclopaedic coverage of the field.

This note explains the following topics: Symbols, strings and languages, Finite automata, Regular expressions and languages, Markov models, Context free languages, Language recognizers and generators, The Chomsky hierarchy, Turing machines, Computability and actability, Computational complexity.

This is a free textbook for an undergraduate course on the Theory of Computation, which have been teaching at Carleton University since 2002.Topics covered includes: Finite Automata and Regular Languages, Context-Free Languages, Turing Machines and the Church-Turing Thesis, Decidable and Undecidable Languages and Complexity Theory.

This course is an introduction to the Theory of Computation. Topics covered includes: Background Mathematics, Models of Computation, Context-Free Grammars, Automata, The Chomsky Hierarchy.

This note provides an introduction to the theory of computational complexity. Topics covered includes: Models of computation, Time and space complexity classes, Nonterminism and NP, Diagonalization, Oracles and relativization, Alternation, Space complexity, Natural proofs, Randomized classes, Counting classes, Descriptive complexity and Interactive proofs.

This note covers the following topics: Automata, Set Theory, The Natural numbers and Induction, Foundations of Language Theory, Operations on Languages, Deterministic Finite Automata, Formal Languages, Computability, Computations of Turing Machines, The Primitive Recursive Functions, The Partial Recursive Functions, DNA Computing, Analog Computing and Scientific Computing.

This book covers the following topics: The RAM Model, The Primitive Recursive Functions, The Partial Recursive Functions, Coding and Godelization, The Hierarchy of Primitive Recursive Functions, Universality and Parametrisation, The type-free lambda calculus.

This note covers the following topics: Graphics Primitives, 2D Transformation and Viewing, 3D Concept and Object Representation, 3D Transformation and Viewing, Depth Buffer Method and Z Buffer Method, Basic illumination model, Shading Model and Lighting Model.

The purpose of this book is to teach you how to write GUI programs using Qt 3. It is assumed that you have a basic knowledge of C++.The code examples use a subset of C++, avoiding many C++ features that are rarely needed when programming Qt.

This note covers the following topics: Overview of Computer Graphics, Display Devices, Scan Conversion, 2D Transformations, Graphics Operations, Interactive Devices, 3D Graphics, The Concept of Multimedia and GKS.

This note provides an introduction to the principles of computer graphics. In particular,it will consider methods for modeling 3-dimensional objects and efficiently generating photorealistic renderings on color raster graphics devices.

This lecture note covers the following topics: Introduction to Graphics, Curves, Transformations, Coordinate Free Geometry, 3D Objects, Camera Models, Visibility, Basic Lighting and Reflection, Basic Ray Tracing, Radiometry and Reflection, Distribution Ray Tracing, Parametric Curves And Surfaces and Animation.

This note explains the following topics: Image Representation, Geometric Transformation, OpenGL Programming, Eigenvalue Decomposition and its Applications in Computer Graphics, Geometric Modelling.

This note is an introduction to the fundamentals of the field of computer graphics. Topics covered includes: Model transformations, Homogeneous Coordinates, View transformations, Projections, View Volume, Projective Transforms, Clipping, windowing, rasterization, Graphics Pipeline, Hidden Surface Removal, Object hierarchies, fractals, L-systems, Cubic Curves and Bicubic Surfaces, Meshes, Lighting, Material, Shading, texture mapping, environment mapping, shadows and interreflections.

This note has two objectives. First is to teach programming. Second is to present some fundamental principles of computer science, especially algorithm design. Major topics covered includes: Recursive Functions, O Notation: Estimating Costs in the Limit, Lists, Sorting, Datatypes and Trees, Dictionaries and Functional Arrays, Queues and Search Strategies, Functions as Values, List Functionals, Polynomial Arithmetic, Sequences, or Lazy Lists, Elements of Procedural Programming, and Linked Data Structures.

This lecture note explains the following topics: What is CS, Java review: Data, control constructs, static methods, Classes: Incorporation, instantiation, inheritance, Generics, Code reuse, Program analysis, Data structures, Lists, stacks, queue.

This note covers the following topics: Computing: The Functional Way, Computing Tool, Algorithms: Design and Refinement, Technical Completeness and Algorithms, Introducing Reals, Correctness, Termination and Complexity, Compound Data, Higher Order Functions and Structured Data, Imperative Programming.

This note focuses on Concurrent Programming, Parallel Programming, Multi-Processing and Multi-Threading. Topics covered includes: Thread, Properties of a Thread, Lifecycle of a process, Concurrent Hardware, Basic Uniprocessor, Multiprocessors, Basic Hardware, Kessel�s Algorithm, Java Threads Scheduling Model, Compiler Optimization and Mutlithreading, Ticket Algorithm, Bakery Algorithm, Semaphores, Concurrency Problems with Deadlock, Speculative Multithreading

This study note explains concurrent programming with an emphasis on correctness and with a simpler and easier machine or programming model.

This note explains core material in data structures and algorithm design, and also helps students prepare for research in the field of algorithms. Topics covered includes: Splay Trees, Amortized Time for Splay Trees, Maintaining Disjoint Sets, Binomial heaps, F-heap, Minimum Spanning Trees, Fredman-Tarjan MST Algorithm, Light Approximate Shortest Path Trees, Matchings, Hopcroft-Karp Matching Algorithm, Two Processor Scheduling, Network Flow - Maximum Flow Problem, The Max Flow Problem and Max-Flow Algorithm.

This Lecture Notes is organized into eleven chapters. Besides the subject matter, each chapter includes a list of problems and a list of programming projects. Also, each chapter concludes with a list of references for further reading and exploration of the subject. Topics covered includes: Lists, Dictionaries, Binary Trees, Balanced Trees , Priority Queues , Directed Graphs, Undirected Graphs, Sorting Methods, 0 Introduction to NP-Completeness.

This book provides implementations of common and uncommon algorithms in pseudocode which is language independent and provides for easy porting to most imperative programming language. Topics covered includes: Data Structures, Linked Lists, Binary Search Tree, Heap, Sets, Queues, Algorithms, Sorting, Sorting.

This note covers the following topics: Lazy Evaluation and S-Notation, Amortization and Persistence via Lazy Evaluation, Eliminating Amortization, Lazy Rebuilding, Numerical Representations, Data-Structural Bootstrapping, Implicit Recursive Slowdown.

In computer science, an algorithm is a self-contained step-by-step set of operations to be performed. Topics covered includes: Algorithmic Primitives for Graphs, Greedy Algorithms, Divide and Conquer, Dynamic Programming, Network Flow, NP and Computational Intractability, PSPACE, Approximation Algorithms, Local Search, Randomized Algorithms.

Purposes to this note is to teach you to program in the C programming language, and to teach you how to choose, implement, and use data structures and standard programming techniques. Topics coverd includes: The Zoo and the Zoo Annex, The Linux programming environment, The C programming language, Data structures and programming techniques.

This note covers the following topics: Divide And Conquer Strategy, Greedy Method, Minimum Spanning Trees, Dynamic Programming, Optimal Binary search trees, Backtracking Method, Branch and Bound, Lower bound Theory.

This note covers the following topics: Fundamentals of data structure, simple data structures, ideas for algorithm design, the TABLE Data Type, free storage management, sorting, storage on external media, variants on the SET Data Type, pseudo-random numbers, data compression, algorithms on graphs, algorithms on strings and Geometric Algorithms.

This lecture note discusses the approaches to designing optimization algorithms, including dynamic programming and greedy algorithms, graph algorithms, minimum spanning trees, shortest paths, and network flows. Also it briefly discusses algorithmic problems arising from geometric settings, that is, computational geometry.

This note covers the following topics related to Algorithm Analysis and Design: Model and Analysis, Warm up problems, Brute force and Greedy strategy, Dynamic Programming, Searching, Multidimensional Searching and Geometric algorithms, Fast Fourier Transform and Applictions, String matching and finger printing, Graph Algorithms, NP Completeness and Approximation Algorithms.

This note covers the following topics: Computational Models, Complexity measures, Power increasing resourses, Basic relatton amomg the models and measures, Reducibility, completeness and closure under reductions, Deterministics and nondeterministics logarithmic space, Deterministics polynomial time, Polynomial Hierarchy and Polynomial space.

This thesis presents efficient algorithms for internal and external parallel sorting and remote data update. Topics covered includes: Internal Parallel Sorting, External Parallel Sorting, The rsync algorithm, rsync enhancements and optimizations and Further applications for rsync.

This note covers the following topics: The Building Blocks of a Fortran Application, Computer Representation of Numbers and Computer Arithmetic, Intrinsic Functions,Input and Output, Arrays, Parametrised Intrinsic Types, Derived Types, Pointers and Targets, Elements of ob ject-oriented programming, Code Performance,Linear Systems of Algebraic Equations, Nonlinear Equations, Polynomial Interpolation, Numerical Integration,Linear Least Squares, Taylor Polynomials.

This book explains the following topics: A quick tour of Fortran 95, The Building Blocks of a Fortran Application, Flow Control, Computer Representation of Numbers and Computer Arithmetic, Applications, Intrinsic Functions, Input and Output, Arrays, Parametrised Intrinsic Types, Derived Types, Pointers and Targets, Elements of object-oriented programming, Code Performance, Linear Systems of Algebraic Equations, Linear Least Squares, Nonlinear Equations, Polynomial Interpolation , Numerical Integration, Piecewise Polynomial Interpolation and Taylor Polynomials.

This note explains the following topics: Variables and Statements, Character Processing, Arrays, Logical and comparison expressions, Control statements, Program units , Interactive Input and Output, File-based Input and Output, Dynamic arrays and Pointer Variables.

This book covers the following topics: Types, Variables, Constants, Operators, Control Constructs, Procedures, Arrays, Modules, Pointers, Numeric Precision, Scope and Lifetime of Variables and Debugging.

This guide is intended as a first introduction to Fortran 90. The guide is not comprehensive; after the student has familiarised her self with the topics presented in this guide she is advised to find a more detailed and comprehensive text book.

This text provides an introduction to programming and problem solving using the Fortran 95 programming language.

This book covers the following topics: Functional Programming, Functional Languages, Standard functions, Numbers and functions, Functions as a parameter, Data structures, Tuples, List Algorithms, Combinatorial Functions, Code transformation.

This note covers the following topics: introduction, pattern matching, The Sieve of Eratosthenes, Fibonacci Series, Folding Lists, Data types, An expression evaluator, Lambda Calculus, Modules, type inference, Uni cation algorithm, The type inference algorithm, Type classes, Functions with varible number of arguments.

This note covers the following topics: functions and their definitions, using the hugs interpreter, haskell basics, higher order functions, more list notations, more on data types, input-output, haskell laws, program synthesis, models of reduction, divide and conquer algorithms, infinite data structures.

This book is a much more appropriate book for a modern programming languages course than a traditional one based on paradigms. Topics covered includes: Parsing, Interpretation, Desugaring, Adding Functions to the Language, From Substitution to Environments, Functions Anywhere, Mutation: Structures and Variables, Recursion and Cycles: Procedures and Data, Objects, Memory Management, Representation Decisions, Desugaring as a Language Feature, Control Operations, Checking Program Invariants Statically: Types, Checking Program Invariants Dynamically: Contracts and Alternate Application Semantics.

Lisp is much more flexible than most languages. Users have such total control over what goes on that if they do not like the syntax of the language, they may change it to suit themselves. Topics covered includes: Characteristics of Lisp, Syntax of Lisp, Lisp Data Structures, Putting lists together, Equality, PROGN, Defining Functions, Programming Example, Iteration: DOTIMES, Global Variables, Lexical Closures, Characters, Arrays, Strings, Sequences, Input in Lisp, Using the Trace Facility, Multiple Values, Output in Lisp, Function Parameters, Looping Constructs and Defmacro.

This note explains the following topics: Accessing MATLAB, Entering matrices, Matrix operations, array operations, Statements, expressions, variables; saving a session, Matrix building functions, For, while, if and relations, Scalar functions, Vector functions, Matrix functions, Command line editing and recall, Submatrices and colon notation, M-files, script files, function files, Text strings, error messages, input, Managing M-files, Hard copy and Graphics.

This note explains the following topics: Accessing MATLAB, Entering matrices, Matrix operations, array operations, Statements, expressions, variables; saving a session, Matrix building functions, For, while, if and relations, Scalar functions, Vector functions, Matrix functions, Command line editing and recall, Submatrices and colon notation, M-files, script files, function files, Text strings, error messages, input, Managing M-files, Hard copy and Graphics.

Introduction to MATLAB for Engineering Students is a document for an introductory course note in MATLAB and technical computing. It focuses on the specific features of MATLAB that are useful for engineering classes. Topics covered includes: Mathematical functions, Matrix generation, Array operations and Linear equations, Introduction to programming in MATLAB, Debugging M-files, Main characteristics of MATLAB.

This note provides only a brief glimpse of the power and flexibility of the Matlab system.Topics covered are: Matlab as a Calculator, Numbers and Formats, Variables, Suppressing output, Vectors, Plotting Functions, Two–Dimensional Arrays, Systems of Linear Equations, Function m–files, Plotting Surfaces and Graphic User Interfaces.

This note covers the following topics: Backus’ FP Systems, Mathematical Functions and First Steps in ML, Basic Datatypes and Lists in ML, Evaluation of Expressions and Recursive Functions, Local Declarations and Modules, Polymorphic Type Checking, Datatype Exception and Recursive Datatypes, Reasoning about Functional Programs, Domain Theory and Fixpoint Semantics, Imperative Programming.

The goal of this tutorial is to end up with a complete user guide to the system, inclduing the libraries, the tools and the extensions, as well as a tutorial on how to write “real” applications, centered around the use of the module system and the compilation manager.

This book is an introduction to programming with the Standard ML programming language.

This note explains the following topics: computing with Matrices and Vectors, Direct Methods for Linear Systems of Equations, DIrect Methods for Linear Least Squares Problems, Filtering Algorithms, Data Interpolation and Data Fitting in 1D, Approximation of Functions in 1D , Numerical Quadrature, Iterative Methods for Non-Linear Systems of Equations, Eigenvalues, Numerical Integration, Structure Preserving Integration.

This book covers the following topics: Numerical Linear Algebra, Solution of Nonlinear Equations, Approximation Theory, Numerical Solution of ODEs and Numerical Solution of PDEs.

Purpose of this note is to introduce several programming paradigms including Object Oriented Programming, Generic Programming, Design Patterns.

This book explains the following topics: Software crisis, Software Evaluation, POP (Procedure Oriented Programming), OOP (Object Oriented Programming), Benefits of OOP, Object Oriented Language, Application of OOP, Introduction of C++, Application of C++, Simple C++ Program, C++ Statements, Structure of C++, Creating Source File, Compiling and Linking.

This book covers the following topics: Introduction to Object-Oriented Methodology, Advanced Object Modeling, Dynamic Modeling, Functional Modeling, System Design and Object Design.

This note covers the following topics: Introduction To Operating System, File System, CPU Scheduling, Memory Management, Disk Scheduling, Process Management, Deadlocks, Case Study Of Unix, Case Study Of MS-DOS, Case Study Of MS-windows NT.

This note aims to explain the structure and functions of an operating system, and illustrate the key operating system aspects. Topics covered includes: Introduction to Operating Systems, Processes and Scheduling, Memory Management, I/O and Device Management, Protection, Filing Systems, Case Study: Unix and Windows NT.

This lecture note covers the following topics: Computer System And Operating System , Process Management, Concurrency, Memory Management, Virtual Memory, Principles Of Deadlock, File System Interface, Mass-storage Structure.

This book covers the following topics: Operating-System Structures, Processes, Threads, CPU Scheduling, Process Synchronization, Deadlocks, Memory Management, VirtualMemory, File-Systems Interface, File-Systems Implementation, Mass Storage Structure, I/O Systems, Protection, security, Distributed System Structures, Distributed File Systems, Distributed Coordination, Real-Time Systems, Multimedia Systems, The Linux System, Windows XP and Influential Operating Systems.

This book covers the following topics: Motherboard, Central processing unit, Computer power supply, Optical disc, Secondary storage, Main memory, Disk operating system, Command Syntax, BATCH FILES, Data structure in disk, File systems, FAT12, File Allocation Table, Floppy disk, AUTOEXEC.BAT, CONFIG.SYS, Computer software, Three layers of software, Software operation, Memory control drivers, Cash memory and UNIX operation system.

This book contains the following topics: Introduction to the BeOS and BFS, File systems, Data Structures of BFS, Attributes, Indexing, and Queries, Allocation Policies, Disk Block Cache, File System Performance, The Vnode Layer and User-Level API.

This note covers the following topics: Inductive Definitions, Transition Systems, Defining a Language, Concrete Syntax, Abstract Syntax Trees, Abstract Binding Trees, Functional Language, Control and Data Flow, Imperative Functional Programming, Cost Semantics and Parallelism, Data Structures and Abstraction, Lazy Evaluation, Dynamic Typing, Subtyping and Inheritance, Concurrency.

This book has been written as lecture notes for students who need a grasp of the basic principles of linear codes. Topics covered includes: Shannon theory and coding, Coding theory, Decoding of linear codes and MacWilliams identity, Coding theory - Constructing New Codes, Coding theory - Bounds on Codes, Reed-Muller codes, Fast decoding of RM codes and higher order RM codes.

This note explains the following topics: Object-oriented programming, Data encapsulation with classes, Subclasses and inheritance, Abstract classes, Exception handling, Reflection, Concurrent programming, Functional programming, Logic programming, Scripting languages.

Covered topics are: Text Compression, Error Detection and Correction, Cryptography, Finite State Machines, Recursion and Induction, Relational Database, String Matching and Parallel Recursion.

This note covers the following topics: Basic Theories, Basic Data Structures, Function Theory, Program Theory, Programming Language, Recursive Definition, Theory Design and Implementation, Concurrency and Interaction.

This book covers the following topics: Introduction to Programming, General Computation Models, Declarative Programming Techniques, Declarative Concurrency, Relational Programming, Object-Oriented Programming, Encapsulated State, Concurrency and State, Specialized Computation Models, Semantics and Virtual Machines.

Think Complexity, 2nd Edition is about complexity science, data structures and algorithms, intermediate programming in Python, and the philosophy of science. The examples and supporting code for this book are in Python. You should know core Python and you should be familiar with object-oriented features, at least using objects if not defining your own.

This document is about BeanShell. BeanShell is a small, free, embeddable Java source interpreter with object scripting language features, written in Java. BeanShell executes standard Java statements and expressions but also extends Java into the scripting domain with common scripting language conventions and syntax. BeanShell is a natural scripting language for Java.

As a reader, you are the most important critic and commentator of our books. We value your opinion and
want to know what we're doing right, what we could do better, what areas you'd like to see us publish in,
and any other words of wisdom you're willing to pass our way. You can help us make strong books that
meet your needs and give you the computer guidance you require.

Certainly, this isn't the first book to be written on the subject of the Common Object Request Broker
Architecture (CORBA)--not by a long shot. However, among CORBA books currently on shelves, it might be
unique in its approach. At the time this book was written, few, if any, texts were available that covered CORBA
at an introductory level. This book attempts to fill that gap.

The ColdFusion Getting Started Server enables you to quickly setup a development or production instance of a
Server without following the installation procedure. The ColdFusion Getting Started Server is a new ‘lighter’ version
of the ColdFusion Server and is ideally suited for developers to quickly setup and run a ColdFusion Server for
testing and debugging purposes.

This book covers the following topics: Introduction to Programming, General Computation Models, Declarative Programming Techniques, Declarative Concurrency, Relational Programming, Object-Oriented Programming, Encapsulated State, Concurrency and State, Specialized Computation Models, Semantics and Virtual Machines.

JOVIAL (J73) is a higher-order programming language. It is being
implemented on many computer systems and used in many
applications areas. Typical applications areas are avionics,
command and control, and missile flight control.

This textbook, Introduction to Programming in Turing, is
intended to be used in a first computer science course. It
emphasizes the basic concepts of programming and sets
programming within the larger context of computer science and
computer science within the context of problem solving and
design.

We hope that you have as much fun reading it as we did
in writing it and that you manage to find as many useful things as we did when compiling
it. The objectives behind this book underwent considerable change between its inception
(at the Dutch User Group "Conference to the Max" held in Arnhem, Holland in May 1999)
and the version of the text which you now hold in your hands. However, the paragraphs
below describe what we finally hoped to achieve with the book.