This java programming site aims to provide book reviews and free ebook on java tutorial, java swing, sun java interface, java struts, java examples, java documentations, java j2ee, java jvm, java util, java j2se, java plugin, java programming, java runtime, java script, java downloads, free java applets, java vm, java certification, java socket, java beans, java source code, java threads, java help, java database, java api, java 1.5, java file, java training, java developments, java tips,java web services, etc

Free ebook - Java Object-oriented Program Design and Software Engineering

By Dave Goddeau

This free ebook entitiled "Java Object-oriented Program Design and Software Engineering" is enriched with 21 lecture notes i.e.
  • Java Introduction,Administration, and Procedural Programming
  • Java Classes
  • The Java String data type
  • Java Inheritance
  • Java Interfaces
  • Java OOP Design and Design Process
  • Java Error and Exception Handling
  • Java Stream I/O
  • Window Systems and Graphics
  • Event-based Programming
  • Java GUI Components (Widgets)
  • Java Threads
  • Java Network Programming
  • Java Software Development Cycle
  • Misc. Topics in Java
  • Java on the Web - Java in the Browser: Applets
  • Java Component Object Models
  • Java OOP
  • Java Software Patterns
  • Persistence, Databases, and Transactions, XML
  • Internationalization and Localisation

Moreover this free java ebook covers lecture videos . They are Introduction to Java, Classes, Inheritance & Polymorphism, Interfaces and interfaces, Design & Design Process, Exceptions & Error Handling, I/O, Window Systems & Graphics, Event-based programming, GUI (widgets), Threads, Network Programming, Software Design Cycle, OOP , Layouts, Packages, & Jar files, Java on the web, Component Object Models, Overview of Software Patterns and Persistence & Databases & etc.

Read More/get this free ebook

Free java ebook - Introduction to Java OOA/OOD for Web Applications

By Alvin J. Alexander

This ebook entitiled Introduction to Java OOA/OOD for Web Applications covers object oriented software development, java programming language basic to advanced, java Standard libraries and Java server side programming.

Contents

Day 1: Object-Oriented Software Development


  • Credits and Other Material




  • Why OO?




  • Benefits of object-oriented programming




  • Symptoms of software development problems



  • Root causes of project failure



  • Software development best practices



  • Introduction to OO concepts



  • Encapsulation



  • Inheritance



  • Polymorphism



  • Abstraction with objects



  • Message passing



  • UML summary



  • Standard diagrams



  • Object Oriented Software Development



  • Why have a process?



  • The Rational Unified Process (RUP)



  • Inception phase



  • Elaboration



  • Construction phase



  • Transition



  • A sample process



  • Domain modeling



  • Use case modeling



  • Robustness analysis



  • Interaction modeling



  • Collaboration and State Modeling



  • Addressing Requirements



  • Survey of Design Patterns



  • Agile Methods



  • The Agile Alliance



  • Introduction to Extreme Programming



  • Risk: The Basic Problem



  • Four Variables



  • The Cost of Change



  • Four Values



  • Basic Principles



  • Back to Basics



  • The Solution



  • OO Summary



  • OO Concepts



  • UML



Day 2: The Java Programming Language


  • Introduction



  • Chapter objectives



  • Java design goals



  • What is Java?



  • How/where to get Java



  • First Steps with Java



  • Java Commands and Utilities



  • A first application



  • main




  • Variables, constants, and keywords



  • Primitive data types



  • Literals



  • Constants



  • Reserved keywords



  • Arrays



  • Strings



  • String objects



  • StringBuffer class



  • Comments and Javadoc



  • Types of comments



  • Javadoc comment tags



  • A comment example



  • Notes on Usage



  • Flow control and loops



  • Introduction



  • Objectives



  • Statements and blocks



  • if-else



  • switch



  • while and do-while



  • for



  • Labels



  • break



  • continue



  • return



  • No goto Statement



  • Classes and objects



  • Introduction



  • Objectives



  • A Simple Class



  • Fields



  • Access Control and Inheritance



  • Creating Objects



  • Constructors



  • Methods



  • this



  • Overloading methods



  • Overriding methods



  • Static members



  • Initialization Blocks



  • Garbage collection and finalize



  • The toString() Method



  • Native Methods



  • Methods and parameters



  • Methods



  • Extending Classes



  • Introduction



  • Objectives



  • An extended class



  • A simple example



  • What protected really means



  • Constructors in extended classes



  • Overriding methods, hiding fields, and nested classes



  • Marking methods and classes final



  • The object class



  • Anonymous classes



  • Abstract Classes and methods



  • Cloning objects



  • Extending classes: how and when



  • Designing a class to be extended



  • Interfaces



  • Introduction



  • Objectives



  • An example interface



  • Single inheritance versus multiple inheritance



  • Extending Interfaces



  • Implementing Interfaces



  • Using an Implementation



  • Marker Interfaces



  • When to Use Interfaces



  • Exceptions



  • Introduction



  • Objectives



  • Creating exception types



  • throw



  • The throws clause



  • try, catch, and finally



  • When to use exceptions



  • Packages



  • Introduction



  • Package Naming



  • Package Access



  • Package Contents



  • Examples



Day 3: Standard Libraries & Server-side Programming


  • Objectives



  • IO: Streams and readers



  • Java networking



  • Introduction



  • Socket



  • ServerSocket



  • ServerSocket lifecycle



  • URL



  • URLConnection



  • Threads



  • Objectives


  • Thread methods
  • Thread references
  • JavaBeans
  • Remote Method Invocation (RMI)
  • Java Native Interface (JNI)
  • Collections framework
  • Lists
  • Maps
  • Collection Utilities
  • Internationalization, localization, and formatting
  • HTTP protocol
  • Request and Response
  • Cookies
  • Servlets and JSPs
  • Objectives
  • Introduction/Background
  • Servlets
  • Objectives
  • Servlet basics
  • HelloWorldServlet
  • Servlet lifecycle
  • HTTPServlet
  • HTTPServletRequest
  • HTTPServletResponse
  • JavaServer Pages
  • What is a JSP?
  • JSP engine/container:
  • Translation time and request time
  • Scriptlets
  • Expressions
  • Declarations
  • Directives
  • Implicit objects
  • Exception handling
  • Survey of other server-side Java technologies
  • XML
  • XSLT
  • Enterprise Java Beans
  • Java Messaging Service
Day 4: Databases, Best Practices, and Final Project
  • Databases and JDBC
  • Getting things set up
  • Connecting to the database
  • Statements
  • getXXX methods
  • Updating the database
  • PreparedStatements
  • A real method
  • JUnit
  • Is Testing Important?
  • Mars Orbiter
  • USS Yorktown
  • Types of tests
  • Unit Testing 101
  • Goals of unit testing?
  • Unit Testing with JUnit
  • A sample JUnit session
  • Recap
  • Best practices
  • Refactoring
  • Final project
  • Bibliography

Free java ebook - Programming Principles in Java: Architectures and Interfaces

By David Schmidt, Kansas State University
This free ebook entitiled "Programming Principles in Java: Architectures and Interfaces" covers computers and programming, Simple Java Applications, Java Arithmetic and Variables, Java Input, Output, and State, Java Component Structure: Method and Class Building, Java Control Structure: Conditional Statements, Java Patterns of Repetition: Iteration and Recursion, Java Data Structure: Arrays, Java Programming to Interfaces, Java Graphical User Interfaces and Event-Driven Programming, Java Text and File Processing, etc. There was once a chapter on data structures, but it desperately needs rewriting.
Chapter 1: Computers and Programming 1
1.1 What is a Computer? 1
1.2 Computer Programming 2
1.3 Programs Are Objects 5
1.4 Operating Systems and Windows 6
1.5 Software Architecture 8
1.5.1 Class Diagrams 9
1.6 Summary 11
1.7 Beyond the Basics 13
1.7.1 Stepwise Refinement 14
1.7.2 Object-Oriented Design 15
1.7.3 Classes Generate Objects 17
1.7.4 Frameworks and Inheritance 18
Chapter 2: Simple Java Applications 20
2.1 An Application and its Architecture 20
2.2 How to Build and Execute an Application 23
2.2.1 Using an IDE 23
2.2.2 Using the JDK 28
2.3 How the Application Works 30
2.3.1 An Execution Trace of the Application 33
2.4 How One Object Constructs Another 35
2.5 Repairing Compiler Error Messages 41
2.6 Summary 43
2.7 Programming Exercises 46
2.8 Beyond the Basics 47
2.8.1 Syntax 47
2.8.2 Semantics 49
2.8.3 Java Packages 51
2.8.4 Java API 51
Chapter 3: Arithmetic and Variables 56
3.1 Integer Arithmetic 57
3.2 Named Quantities: Variables 59
3.2.1 Variables Can Vary: Assignments 63
3.3 Arithmetic with Fractions: Doubles 68
3.4 Booleans 72
3.5 Operator Precedences 74
3.6 Strings, Characters, and their Operations 75
3.7 Data-Type Checking 80
3.8 Input via Program Arguments 83
3.8.1 Converting between Strings and Numbers and Formatting 86
3.8.2 Temperature Conversion with Input 88
3.9 Diagnosing Errors in Expressions and Variables 92
3.10 Java Keywords and Identifiers 95
3.11 Summary 95
3.12 Programming Projects 97
3.13 Beyond the Basics 102
3.13.1 Longs, Bytes, and Floats 102
3.13.2 Helper Methods for Mathematics 103
3.13.3 Syntax and Semantics of Expressions and Variables 105
Chapter 4: Input, Output, and State 107
4.1 Interactive Input 108
4.1.1 Dialog Output 112
4.2 Graphical Output 113
4.2.1 Panels and their Frames 113
4.2.2 Customizing Panels with Inheritance 115
4.3 Format and Methods for Painting 122
4.3.1 Constructor Methods and this Object 124
4.4 Objects with State: Field Variables 130
4.4.1 Using Fields to Remember Inputs and Answers 135
4.4.2 Scope of Variables and Fields 140
4.5 Testing a Program that Uses Input 142
4.6 Summary 144
4.7 Programming Projects 147
4.8 Beyond the Basics 151
4.8.1 Scope of Variables and Fields 151
4.8.2 Partial API for JFrame 152
4.8.3 Methods for GregorianCalendar 152
4.8.4 Colors for Graphics 152
5.8.5 Applets 153
Chapter 5: Component Structure: Method and Class Building 157
5.1 Methods 158
5.2 Public Methods 159
5.2.1 Basic Public Methods 160
5.2.2 Constructor Methods 164
5.3 Parameters to Methods 168
5.3.1 Forms of Parameters 173
5.4 Case Study: General Purpose Output Frame 179
5.5 Results from Methods: Functions 186
5.6 Private Methods 193
5.7 Summary 200
5.8 Programming Projects 203
5.9 Beyond the Basics 212
5.9.1 Naming Variables, Methods, and Classes 212
5.9.2 Generating Web Documentation with javadoc 213
5.9.3 Static Methods 217
5.9.4 How the Java Compiler Checks Typing of Methods 220
5.9.5 Formal Description of Methods 221
5.9.6 Revised Syntax and Semantics of Classes 227
Chapter 6: Control Structure: Conditional Statements 229
6.1 Control Flow and Control Structure 230
6.2 Condtional Control Structure 231
6.2.1 Nested Conditional Statements 235
6.2.2 Syntax Problems with Conditionals 240
6.3 Relational Operations 241
6.4 Uses of Conditionals 245
6.5 Altering Control Flow 249
6.5.1 Exceptions 250
6.5.2 System Exit 251
6.5.3 Premature Method Returns 252
6.6 The Switch Statement 252
6.7 Model and Controller Components 255
6.7.1 Designing an Application with a Model-View-Controller Architecture 257
6.8 Case Study: Bank Accounts Manager 259
6.8.1 Collecting Use-Case Behaviors 259
6.8.2 Selecting a Software Architecture 261
6.8.3 Specifying the Model 261
6.8.4 Writing and Testing the Model 261
6.8.5 Specifying the View Components 265
6.8.6 A Second Look at the Software Architecture 265
6.8.7 Writing the View Classes 265
6.8.8 Controller Construction and Testing 272
6.8.9 Testing the Assembled Application 276
6.8.10 Multiple Objects from the Same Class 277
6.9 More about Testing Methods and Classes 283
6.9.1 Testing Individual Methods 283
6.9.2 Testing Methods and Attributes Together 283
6.9.3 Testing a Suite of Methods 284
6.9.4 Execution Traces 285
6.10 Summary 286
6.11 Programming Projects 290
6.12 Beyond the Basics 295
6.12.1 The Logic of the Conditional Statement 295
6.12.2 Interface Specifications and Integration 300
Chapter 7: Patterns of Repetition: Iteration and Recursion 304
7.1 Repetition 305
7.2 While Loops 306
7.3 Definite Iteration 308
7.3.1 Definite-Iteration Example: Painting a Bulls-Eye 153
7.4 Nontermination 319
7.5 Indefinite Iteration: Input Processing 321
7.5.1 Indefinite Iteration: Searching 324
7.6 For-Statements 328
7.7 Nested Loops 329
7.8 Writing and Testing Loops 335
7.9 Case Study: Bouncing Ball Animation 338
7.10 Recursion 347
7.10.1 An Execution Trace of Recursion 352
7.11 Counting with Recursion 356
7.11.1 Loops and Recursions 359
7.11.2 Counting with Multiple Recursions 360
7.12 Drawing Recursive Pictures 363
7.13 Summary 366
7.14 Programming Projects 370
7.15 Beyond the Basics 378
7.15.1 Loop Termination with break 379
7.15.2 The do-while Loop 380
7.15.3 Loop Invariants 381
7.15.4 Loop Termination 386
7.12.5 More Applets 387
Chapter 8: Data Structure: Arrays 391
8.1 Why We Need Arrays 392
8.2 Collecting Input Data within Arrays 396
8.3 Translation Tables 399
8.4 Internal Structure of One-Dimensional Arrays 402
8.5 Arrays of Objects 406
8.6 Case Study: Databases 3409
8.6.1 Behaviors 412
8.6.2 Architecture 413
8.6.3 Specifications 413
8.6.4 Implementation 415
8.6.5 Forms of Records and Keys 420
8.7 Case Study: Playing Pieces for Card Games 424
8.8 Two-Dimensional Arrays 431
8.9 Internal Structure of Two-Dimensional Arrays 434
8.10 Case Study: Slide-Puzzle Game 437
8.11 Testing Programs with Arrays 446
8.12 Summary 448
8.13 Programming Projects 450
8.14 Beyond the Basics 458
8.14.1 Sorting 458
8.14.2 Searching 462
8.14.3 Time-Complexity Measures 465
8.14.4 Divide-and-Conquer Algorithms 469
8.14.5 Formal Description of Arrays 477
Chapter 9: Programming to Interfaces 483
9.1 Why We Need Specifications 484
9.2 Java Interfaces 485
9.2.1 Case Study: Databases 493
9.3 Inheritance 497
9.4 Reference Types, Subtypes, and instanceof 500
9.5 Abstract Classes 508
9.5.1 Case Study: Card Players 509
9.5.2 Class Hierarchies 516
9.5.3 Frameworks and Abstract Classes 519
9.6 Subtypes versus Subclasses 519
9.7 class Object and Wrappers 520
9.8 Packages 522
9.8.1 Generating Package APIs with javadoc 524
9.9 Case Study: An Adventure Game 526
9.9.1 Interfaces and Inheritance Together 532
9.9.2 Inheritance of Interfaces 539
9.10 Summary 539
9.11 Programming Projects 543
9.12 Beyond the Basics 544
9.12.1 Subclasses and Method Overriding 545
9.12.2 Semantics of Overriding 550
9.12.3 final components 555
9.12.4 Method Overloading 556
9.12.5 Semantics of Overloading 561
Chapter 10: Graphical User Interfaces and Event-Driven Programming 564
10.1 Model-View-Controller Revisited 565
10.2 Events 567
10.3 The AWT/Swing Class Hierarchy 568
10.4 Simple Windows: Labels and Buttons 571
10.5 Handling an Event 579
10.5.1 A View as Action Listener 579
10.5.2 A Separate Controller 583
10.5.3 A Button-Controller 583
10.6 Richer Layout: Panels and Borders 590
10.6.1 An Animation in a Panel 594
10.7 Grid Layout 600
10.8 Scrolling Lists 604
10.9 Text Fields 610
10.10 Error Reporting with Dialogs 617
10.11 TextAreas and Menus 620
10.11.1 Case Study: Text Editor 623
10.12 Event-Driven Programming with Observers 632
10.12.1 Observers and the MVC-Architecture 635
10.13 Summary 636
10.14 Programming Projects 641
10.15 Beyond the Basics 645
10.15.1 Applets 646
10.15.2 Tables and Spreadsheets 649
10.15.3 Handling Mouse Clicks and Drags 655
10.15.4 Threads of Execution 664
10.15.5 GUI Design and Use-Cases 669
10.15.6 Summary of Methods for Graphical Components 671
Chapter 11: Text and File Processing 680
11.1 Strings are Immutable Objects 681
11.1.1 String Tokenizers 683
11.2 Sequential Files 686
11.2.1 Output to Sequential Files 688
11.2.2 Input from Sequential Files 690
11.3 Sequential Input from the Command Window 692
11.4 Case Study: Payroll Processing 695
11.5 Exceptions and Exception Handlers 700
11.5.1 Restarting a Method with an Exception Handler 702
11.5.2 Interactive Input with Exception Handlers 705
11.6 Exceptions Are Objects 706
11.6.1 Programmer-Generated Exceptions 713
11.7 Summary 714
11.8 Programming Projects 716
11.9 Beyond the Basics 719
11.9.1 Character-by-Character File Processing 719
11.9.2 Binary Files and Files of Objects 720
11.9.3 A Taxonomy of File Classes 721
11.9.4 A GUI for File Selection 730
Appendix I:Java Language Definition 724
Appendix II:Types and Subtypes 741
Appendix III:Class Diagrams 744
Index 748

Interactive Programming In Java Ebook

By Lynn Andrea Stein
How to Use This EBook
Interactive Programming is designed for use by students who have no prior programming experience (typically college freshmen). It ultimately teaches both the fundamentals of computer programming and the details of the Java programming language.
The book is divided into five parts. The first briefly overviews the idea of programs built out of communities of interacting entities. The second part introduces the mechanics of Java programming, from things, types, and names to objects and classes. It is essential to the book and is intended to be read in the order presented. Part three elaborates on these ideas, introducing threads as first-class citizens of the programming world and exploring inheritance, exception-handling, and design. Part four emphasizes a variety of issues in the design of an individual entity. It is not necessary to read this section in any particular order, and certain chapters can be omitted entirely without serious detriment. Part five similarly surveys a variety of interrelated topics, in this case concerning the ways in which communities are coupled together, and its chapters, too, can be taken out of order or omitted.
The five parts, taken together, constitute a single-semester introductory course in computer programming. In such a course, some of the supplementary material (described below) will not be used. For a one-quarter course, part five and selected earlier chapters should probably be omitted. Alternately, the complete book can be spread over two quarters or over a full year, augmented as necessary from the supplementary materials.
Part By Part
Part 1 is brief and introductory, providing an overview of the approach to computer programming taken. Part 2 begins with the basic syntax and semantics of programming constructs. At the same time, from the earliest examples, students are introduced to concurrent, interactive, embedded programs. For example, interfaces are introduced early as they specify a contract between two parts of a computer system. By the middle of part 3, students have learned to write what might in other contexts be called "stand-alone" programs -- complete programs including class definitions and a main routine. They have also learned that every program is a part of a system of interacting entities -- including the user, libraries and other software, hardware, etc. -- and that no program truly stands alone.
The remainder of the book addresses issues and alternatives that arise in the design of software communities. Part 4 focuses on ways to extend the basic entities that students build. The notion of a dispatching control loop provokes an exploration of procedural abstraction, in which separate routines handle each possible case. This in turn leads to a de-emphasis of the central control loop and a shift to event-driven programming, in which individual "handler" procedures take center stage. In a typical event system, dispatch may be provided implicitly, i.e., by underlying hardware or software. A third model -- smart objects that handle their own behavior -- is also explored. Java's AWT is introduced as both a tool and an example of an event-based system.
Part 5 addresses the issue of how entities are tied together. A recurring theme -- throughout the book, but emphasized here -- concerns interface design. This refers both to the Java construct -- a signature specification, introduced in chapter 4 -- and to the more general concept, including human (user) interface design. In addition to learning how to specify an interface, students learn what the interface does not specify. In other chapters, students learn about streams, messages, and shared memory, about connecting to objects in the same name space and to those running under different processes or on different machines, and about how to communicate with them. They also learn the basic ideas of safety and liveness, that shared mutable state can lead to program failures, and some simple mechanisms for coping with them. They do not, of course, learn to build arbitrarily complex programs that avoid deadlock under all circumstances. This topic will be visited later in the computer science curriculum. Instead, they learn to recognize the general preconditions for the possibility of safety failures and the kinds of solutions that might be possible. The goal, throughout this course, is to give students the basic conceptual vocabulary that will allow them to ask the right questions as they meet more complex issues later in their education.
Interactive Programming ends with an overview of various patterns of large-scale systems architecture, reviewing tradeoffs among various approaches and providing a common language for software architects. The last chapter examines conventional patterns by which complex concurrent and distributed systems are constructed. The emphasis is on designing and understanding a variety of interactive communities. This chapter also leads naturally into final projects. In courses taught using this curriculum and preliminary drafts of the book, typical final projects have included client/server chat programs and networked video games. Not what you would generally expect from first semester freshmen!

Ebooks - Sun Certified Java Programmer Pre-Exam Essentials

By Dylan Walsh
The purpose of this document is to provide a basis for revising for the Sun Certified Programmer examinations, not to teach the Java language or the topics required for the exam. It is designed to collect all the essential information you need to retain, in one place, and is designed for someone who has already finished their own study and is about to take the exam.
This version is written according to the objectives of the "Sun Certified Programmer For Java™ 2 Platform 1.4" exam. For those taking the 1.2 exam, the objectives no longer required for 1.4 have been retained towards the end of this document. The sections have "1.2 Exam Only" at the start of their titles. I would recommend doing the 1.4 exam instead, as it is more current and the only major new subject is assertions.
Aside: There is no 1.3 exam, as such. The 1.1 exam exam was replaced by a Java2 exam, which at the time seemed like it would suffice for all Java2 releases. However in September 2002 Sun released seperate 1.2 and 1.4 exams. The 1.2 syllabus is for 1.2 and 1.3.
Thank you to everyone who has emailed me with compliments and/or corrections for previous versions of this document, it is appreciated. On the other hand, if you have questions on the exam or Java, I am afraid I do not have time to answer all of these, so please try either the certification discussion groups on the web, or the Java newsgroups.
Having obtained my certification, I have neither time or reason to maintain this document in the future and keep it current with changes in the exam. Rather than let it stagnate, I have decided to release it as a resource to the Java certification community under the Free Documentation License. This will allow others to change, correct, expand and update it. The accompanying XML file has more information on how to do this.
If you are just starting to prepare for the exam, then I recommend the following steps:
  1. Buy a good certification book, read the chapters, and do all of the example questions and exercises. This is advisable even if you are already experienced in Java. According to Barry Boones book, Java instructors have failed this exam. Apparently, many people have to take the exam more than once. For experienced programmers, there are things which are examined that you may not encounter in everyday programming, or would lookup in the Javadocs as needed. On the other hand, there are many things experienced developers ought to know but often do not. This exam is regarded as being more difficult than most other certifications.
  2. The books I used to study for the exam were versions of the Roberts, Heller et al book. and the book by Barry Boone. You can find more details on the latest versions of these on the web, and there are more recent books which may be worthwhile. You don't need to buy both, but I found that a good way to study was to do one chapter from each every evening. I did chapters on different topics, which made it more interesting and meant that I revised the same topic later in the other book.
  3. There are courses available, which I cannot comment on, as I studied for the exam without sitting any courses. While these may be worthwhile, I suggest you still follow step 1, as they may be general Java courses and not cover some of the specific issues which come up in the exam.
  4. When you are finished studying, do any and all mock exams available. In addition to those which come with the books, there many available online and you can find lists of links to them on some of the websites below. Do not sit the exam until you are getting marks comfortably above the pass level. I suggest studying until you get atleast 10% more in practice exams than the minimum required for the real exam. A habit you may find useful is when you are marking yourself, for every question you get wrong, hit yourself over the head with a baseball bat... Just kidding, for every question you get wrong, find out what the right answer is, and why, and write that down in a notebook for future revision. Make sure you do the free Sun sample questions as they most accurately reflect the exam.
  5. Read this document again the night, or morning, before you take the exam.

Read More/get this free ebook

Introduction to Programming in Java - ebook

By Robert Sedgewick and Kevin Wayne
This booksite supplements the forthcoming textbook Introduction to Computer Science in Java by Robert Sedgewick and Kevin Wayne.
Textbook.
Our book is an interdisciplinary approach to the traditional CS1 curriculum. We teach all of the classic elements of programming, using an "objects-in-the-middle" approach that emphasizes data abstraction. The book is organized around four areas of computer science: programming, machine architecture, theory, and systems.
  • Chapter 1: Elements of Programming introduces variables, assignment statements, built-in types of data, conditionals and loops, arrays, and input/output, including graphics and sound.
  • Chapter 2: Functions introduces modular programming. We stress the fundamental idea of dividing a program into components that can be independently debugged, maintained, and reused.
  • Chapter 3: Object Oriented Programming introduces data abstraction. We emphasize the concept of a data type and its implementation using Java's class mechanism.
  • Chapter 4: Algorithms and Data Structures introduces classical algorithms for sorting and searching and fundamental data structures, including stacks, queues, and symbol tables.
  • Chapter 5: A Computing Machine introduces an imaginary machine that is similar to real computers. We specify the machine in full detail and consider machine-language programs.
  • Chapter 6: Circuits introduces circuits and logical design, culminating in a description of how a machine might be built from the ground up.
  • Chapter 7: Theory of Computation introduces the scientific discipline concerned with understanding (efficient) computational phenomena, whether it be man-made, in nature, or imaginary.
  • Chapter 8: Systems introduces the basic components of computer systems that support programming: compilers, operating systems, networks, and application systems.
  • Chapter 9: Scientific Computation introduces some of the most important algorithms that play crucial roles in our computational infrastructure, including numerical integration, matrix computation, data analysis, and Monte Carlo simulation.

A key feature of the book is the manner in which we motivate each programming concept that we address by examining its impact on specific applications, taken from fields ranging from materials science to genomics to astrophysics to internet commerce. This approach highlights the essential idea that mathematics, science, engineering, and computing are intertwined in the modern world. It also both reinforces and takes advantage of students' preparation in high-school math and science as they learn programming.

Read More/get this free ebook

Popular Posts