Monday, July 26, 2010

Data Structures and Algorithms: Annotated Reference with Examples

0 comments
This book written by Granville Barnett and Luca Del Tongo is part of an effort to provide all developers with a core understanding of algorithms that operate on various common, and uncommon data structures.

Granville Barnet wrote:

Every book has a story as to how it came about and this one is no different, although we would be lying if we said its development had not been somewhat impromptu. Put simply this book is the result of a series of emails sent back and forth between the two authors during the development of a library for the .NET framework of the same name (with the omission of the subtitle of course!). The conversation started off something like, "Why don't we create a more aesthetically pleasing way to present our pseudocode?" After a few weeks this new presentation style had in fact grown into pseudocode listings with chunks of text describing how the data structure or algorithm in question works and various other things about it. At this point we thought, "What the heck, let's make this thing into a book!" And so, in the summer of 2008 we began work on this book side by side with the actual library implementation.

A key factor of this book and its associated implementations is that all algorithms (unless otherwise stated) were designed by us, using the theory of the algorithm in question as a guideline (for which we are eternally grateful to their original creators). Therefore they may sometimes turn out to be worse than the "normal" implementations -- and sometimes not. We are two fellows of the opinion that choice is a great thing. Read our book, read several others on the same subject and use what you see fit from each (if anything) when implementing your own version of the algorithms in question.

View/Download Data Structures and Algorithms: Annotated Reference with Examples

Introduction to Computer Science

0 comments
This course covers the basics of solving computational problems by writing computer programs in the Java language। We will follow the book exactly: expressions, functions, recursive computation, scratch pad (or iterative) computation, objects, arrays, and interaction.


Introduction to Computer Science
Author : Ken Been, Computer Science Department, Yeshiva University
License : GNU Free Documentation License
Publication Date : 2007


View/Download Introduction to Computer Science | Course webpage

How to Think Like a Computer Scientist: Learning with Python

0 comments
This book was based on Allen Downey's How to Think Like a Computer Scientist, a clear and helpful first-year computer science textbook, which was also released under GNU Free Documentation License. The book's goal is to teach you to think like a computer scientist. This way of thinking combines some of the best features of mathematics, engineering, and natural science.

Python was chosen to translate Allen's original Java version because it provides a really nice balance between the practical and the conceptual. Since Python is interpreted, beginners can pick up the language and start doing neat things almost immediately without getting lost in the problems of compilation and linking. Furthermore, Python comes with a large library of modules that can be used to do all sorts of tasks ranging from web-programming to graphics. Having such a practical focus is a great way to engage students and it allows them to complete significant projects.

Python can also serve as an excellent foundation for introducing important computer science concepts. Since Python fully supports procedures and classes, students can be gradually introduced to topics such as procedural abstraction, data structures, and object-oriented programming -- all of which are applicable to later courses on Java or C++. Python even borrows a number of features from functional programming languages and can be used to introduce concepts that would be covered in more detail in courses on Scheme and Lisp.

Using a very high-level language like Python allows a teacher to postpone talking about low-level details of the machine until students have the background that they need to better make sense of the details. Eventually, it allows the teacher to better focus on the actual topic at hand while allowing students to complete substantial class projects.


How to Think Like a Computer Scientist: Learning with Python
Author(s) : Allen B. Downey, Jeffrey Elkner and Chris Meyers
Publication date : 2002
Publisher : Green Tea Press
Free license : GNU Free Documentation License


View/Download How to Think Like a Computer Scientist: Learning with Python

How To Think Like A Computer Scientist: Learning with C++

0 comments
Allen B. Downey, professor of Computer Science at Wellesley College, originally wrote How to Think Like a Computer Scientist, the JavaTM Version, as a textbook for his computer science class. Over the summer of 1998, he converted the original Java version into C++. Since then, the Java version has undergone several major changes, including the addition of Abstract Data Types such as Stacks, Queues, and Heaps. The C++ version of the open textbook however, did not receive these changes, until Jonah Cohen, Paul Bui and Charles Harrison came along.

Like the original Java version, the C++ version's goal is to teach you to think like a computer scientist. This way of thinking combines some of the best features of mathematics, engineering, and natural science. Like mathematicians, computer scientists use formal languages to denote ideas (specifically computations). Like engineers, they design things, assembling components into systems and evaluating tradeoffs among alternatives. Like scientists, they observe the behavior of complex systems, form hypotheses, and test predictions.

The single most important skill for a computer scientist is problem-solving. That is, the ability to formulate problems, think creatively about solutions, and express a solution clearly and accurately. As it turns out, the process of learning to program is an excellent opportunity to practice problem-solving skills.


How To Think Like A Computer Scientist: Learning with C++
Author(s) : Allen B. Downey, Paul Bui, Jonah Cohen and Charles Harrison
Publication date : Jul 2001
Free license : GNU Free Documentation License


View/Download How To Think Like A Computer Scientist: Learning with C++ | Mirror #1 | Mirror #2

How To Think Like A Computer Scientist, Java Version

0 comments
The goal of this book is to teach you how to think like a computer scientist. This way of thinking combines some of the best features of Mathematics, Engineering, and Natural Science. Like mathematicians, computer scientists use formal languages to denote ideas (specifically computations). Like engineers, they design things, assembling components into systems and evaluating tradeoffs among alternatives. Like scientists, they observe the behavior of complex systems, form hypotheses, and test predictions.

The single most important skill for a computer scientist is problem-solving. That is, the ability to formulate problems, think creatively about solutions, and express a solution clearly and accurately. As it turns out, the process of learning to program is an excellent opportunity to practice problem-solving skills.

On one level, you will be learning to program, which is a useful skill by itself. On another level you will use programming as a means to an end. As you go along this book, that end will become clearer.

The order of presentation in this book is what might be called procedural first, which in general, the programming style is procedural (or functional) until the later chapters, which include a brief introduction to the concepts of object- oriented programming.


How To Think Like A Computer Scientist, Java Version
Author(s) : Allen B. Downey
Publication date : 2002
Free license : GNU Free Documentation License

View/Download How To Think Like A Computer Scientist, Java Version | Mirror #1

How To Design Programs: An Introduction To Programming and Computing

0 comments
This introduction to programming places computer science in the core of a liberal arts education. Unlike other introductory books, it focuses on the program design process. This approach fosters a variety of skills--critical reading, analytical thinking, creative synthesis, and attention to detail--that are important for everyone, not just future computer programmers.

The book exposes readers to two fundamentally new ideas. First, it presents program design guidelines that show the reader how to analyze a problem statement; how to formulate concise goals; how to make up examples; how to develop an outline of the solution, based on the analysis; how to finish the program; and how to test. Each step produces a well-defined intermediate product. Second, the book comes with a novel programming environment, the first one explicitly designed for beginners. The environment grows with the readers as they master the material in the book until it supports a full-fledged language for the whole spectrum of programming tasks.

All the book's support materials are available for free on the Web. The Web site includes the environment, teacher guides, exercises for all levels, solutions, and additional projects.

Reviews:

Amazon.com

"... it focused on how to 'design' programs, not just how to program, while college classes are mostly focused on how to write programs."


How To Design Programs: An Introduction To Programming and Computing
Author(s) : Matthias Felleisen, Robert Bruce Findler, Matthew Flat, and Shriram Khrisnamurti
Publication date : May 2002
ISBN : 0-262-06218-6
Pages : 720
Publisher : MIT Press


View/Download How To Design Programs

How to be a Programmer: A Short, Comprehensive, and Personal Summary

0 comments
Having read this essay, I can't help but to wish that I had read it when I first started my career as a professional programmer. The author has done a great job of summarizing so many things we need to know as a programmer, from a programmer perspective. Started from the basic technical skills every programmer must acquire, to managerial skill one must have to manage a team of programmers (some of us don't wish to stay as a programmer for the rest of our career).

Emphasizes are put on the ethic of working as a programmer and as a member of the team. The requirement analysis may blurry, the individual team member skill may not be equal, and deadlines may be impossible, but that's all of it. We can't really complain because all of those must be accepted as the natural of professional programming. Inside this essay you'll find tips on how to learn communication language among your peers, how to talk to non-engineers, and how to deal with difficult people. As programmers are also human with their personal lives and personal problems, this essay also show us how to take a break when needed, and how to recognize when to go home, and how to communicate and negotiate with your boss, so that you won't end up working heroically for 50 to 60 hours a week.

All said and done, this is a very nice essay, one that should be a mandatory for wannabe and professional programmers. And if you?re happened to be a manager who supervise a hive of programmers, this essay should provide you with an useful insight into their beautiful minds and habits.


How to be a Programmer: A Short, Comprehensive, and Personal Summary
Author(s) : Robert L. Read
Publication Date : 2003
Free License : GNU Free Documentation License, Version 1.2 or later


View/Download How to be a Programmer

Concrete Abstractions - An Introduction to Computer Science Using Scheme

0 comments
At first glance, the title of this book is an oxymoron. After all, the term abstraction refers to an idea or general description, divorced from physical objects. On the other hand, something is concrete when it is a particular object, perhaps something that we can manipulate with our hands and look at with our eyes. Yet we often deal with concrete abstractions, and so this book will introduce several abstract ideas in as concrete a way as possible. As the reader become familiar and comfortable with these ideas, they will begin to think of the abstractions as actual concrete objects. It is this way of thinking, that makes computer science can be referred as the discipline of concrete abstractions.

This book offers the students a hands-on, abstraction-based experience of thinking like a computer scientist. It covers the basics of programming and data structures, and gives first-time computer science students the opportunity to not only write programs, but to prove theorems and analyze algorithms as well. Students learn a variety of programming styles, including functional programming, assembly-language programming, and object-oriented programming (OOP). While most of the book uses the Scheme programming language, Java is introduced at the end as a second example of an OOP system and to demonstrate concepts of concurrent programming.

Intended Audience :

This book is primarily intended as the text for a first undergraduate course in computer science. The ideal is that every college student should have a trial experience of what it's like to think abstractly, the way mathematicians and computer scientists think. The tangible nature of the computer scientist's abstractions should attract some of the students who choose to avoid math courses. Because of this, this book doesn't require that the students have taken a college-level math course. On the other hand, mathematics is used in computer science in much the same way it is used in biology, chemistry, and physics. Thus a knowledge of high school algebra is assumed.

Similarly, this book also assume that the reader may not have had much computing or programming experience, beyond playing an occasional computer game or using a word processor. However, this book does not describe how to start a computer, how to use a Scheme programming environment, or similar mechanics. This kind of information varies greatly from machine to machine and is best taught by a person rather than a book.

Reviews:

Amazon.com

"The book starts in Scheme, then adds object oriented techniques and assembly language. It finishes with a transition to Java, which is, of course, similar to C++. This approach will provide a much broader background than a typical text using C++ or C could."

"Concrete Abstractions provides a great intoduction to the world of Computer Science. It covers well basic ideas of abstractions, software design, algorithms, sorting, and much more."


Concrete Abstractions - An Introduction to Computer Science Using Scheme
Author(s) : Max Hailperin, Barbara Kaiser, and Karl Knight
ISBN : 0-534-95211-9
Paperback : 686 pages
Publication Date : 1999
Publisher : Course Technology

Terms and Conditions:
The PDF files for Concrete Abstractions: An Introduction to Computer Science Using Scheme are made available for your personal educational use। For your own use, you may make a copy in any form. However, you must not pass any copy on to anyone else, and you must not place any copy on a server for others to download.


View/Download Concrete Abstractions - An Introduction to Computer Science Using Scheme

A College Student's Guide to Computers in Education

0 comments
This short book is for undergraduate and graduate college and university students, and for others thinking about enrolling in higher education courses. The information and ideas presented will help you to obtain an education that will be useful to you throughout your life in our rapidly changing Information Age world.

Change is an underlying theme of this book. You are living at a time of a rapid technological change. The rate of change is increasing. Such change brings with it both threats and opportunities. You can shape your informal and formal education to diminish the threats and increase the opportunities.

Gaining a competitive advantage is another underlying theme of the book. Whatever your areas of interest, you can gain a competitive advantage by developing a higher level of expertise in the areas and by developing an increased level of expertise in using computers in the areas. Computer technology is a powerful aid to representing and helping to solve problems and accomplish tasks in every academic discipline.


A College Student's Guide to Computers in Education
Author : David Moursund, College of Education, University of Oregon
Publication Date : 2007
Free License : Creative Commons Attribution-Noncommercial 3.0 License


View/Download A College Student's Guide to Computers in Education

A Beginners C++

0 comments
A Beginners C++ is primarily intended for introductory Computer Science courses that use C++ as an implementation language. However, the book should be equally suited to an individual who wants to learn how to program their own personal computer.

This book assumes that you are a computer literate. You are required to have experience with word processing packages, and possibly other packages like spreadsheets and data bases. Although most schools do provide a limited introduction to programming (usually in Pascal or possibly a dialect of Basic), this book does not rely on such past experience.

It is expected that you will use one of the modern Integrated Development Environments (IDE) on a personal computer. Examples of such environments include the Borland environment for Intel PCs and the Symantec environment for Macintosh/PowerPC machines.


A Beginners C++
Author(s) : Neil Gray
Publication date : 2002


View/Download A Beginners C++

A Balanced Introduction to Computer Science

0 comments
There are three main goals to this text and its accompanying resources. First, it serves to expose the student to the breadth that is the field of computer science. Computer science is more than just the study of computers – it focuses on all facets of computation, from the design and analysis of algorithms (step-by-step sequences of instructions for carrying out tasks), to the engineering and manufacture of computer components, to the development of software systems. Through readings and the use of online resources, the student will study topics such as the history of computer technology, the underlying architecture of modern computers, the translation and execution sequence of programs, and the capabilities and limitations of computation. Using software simulators, the student will build virtual components of a computer and watch the flow of information as a program is translated and executed on the low-level machinery. Through this combination of reading and experimentation, hopefully these concepts will come alive for the student and provide a sense of what computer science is all about.

The second main goal of this text is to teach the student the fundamentals of programming. Programming is the process of solving problems on the computer, that is, devising solutions to specific tasks and formalizing those solutions in a language the computer can understand and execute. Programming is the central activity in computer science, providing an inroad to many of the interesting facets and challenges of the field. In learning to program, the student will be learning to analyze problems, think logically, formalize his or her thoughts, and solve problems. It is a discipline, since a systematic approach must be learned, but it is also a creative process, since novel approaches must be found to attack new problems. And since many of the skills developed in programming apply to problem solving in general, experience gained through this text should carry over to other disciplines as well.

The third main goal of this text is to demonstrate the scientific and interdisciplinary nature of computing. Research in various fields of study, most notably the mathematical and natural sciences, is becoming increasingly dependent on computers and programming. By studying and investigating applications in fields such as biology, physics, psychology, and even economics, the student will learn to apply his or her programming skills to a wide range of problems. In addition, the student will develop empirical skills that are common to all scientific endeavors.

Reviews:

Amazon.com

"If you are in the queue to teach an introduction to computer science course, then you should examine this book. It is well written and the level of presentation is appropriate for the typical student taking such a course. It could also be used for self-study."

"I would never recommend this book to anyone. If the author wanted to keep the subject simple, he should have avoided the technical details all together. If he wanted to present some technical detail, then he should have made sure that they don't contradict each other and are not missing important points and updates."


A Balanced Introduction to Computer Science
Author : David Reed, Department of Computer Science, Creighton University, Omaha
ISBN : 013046709X
Pages : 400
Publisher : Prentice Hall
Publication Date : 2004


View/Download A Balanced Introduction to Computer Science

Structure and Interpretation of Computer Programs - Video Lectures

0 comments
Those are the opening words from Harold Abelson for the course of Structure and Interpretation of Computer Programs given in July 1986 for Hewlett-Packard employees. Converted in its entirety into Mpeg and DivX formats, these video lectures are also the first introduction given to the students of entry-level Computer Science subject at M.I.T.

These lectures are accompanied by the book of Structure and Interpretation of Computer Programs, also written by Harold Abelson and Gerald Jay Sussman. The authors use Lisp, but didn't delve formally into the language. Lisp dialect and syntax is used to convey the real issues, that is about finding out what to compute, how to decompose, problems into manageable parts, and build solutions on each of the, parts. Each solutions is wrapped as a black box, and several of these black boxes can be used to build a bigger box. And this bigger box can be used to build an even bigger box, until we finish defining the whole problem and its solutions.

Even though the video lectures were shot in 1986, they will still be useful for students using the second edition (of the textbook), since the overall themes of the course and order of presentation are unchanged. They also still make a excellent introduction to the business of computer science. Actually, the word 'still' doesn't serve it right, since I can't see how the very essence of computer science being conveyed in these video lectures is going to get obsolete. No matter how much progress we made in the terms of hardware sophistication and software development tools proliferation, the basic of computer science is not going to change.

Intended Audience:

As an introduction, these video lectures are aimed for audience with little or no prior formal training in computation. Some background in mathematics is assumed.


Structure and Interpretation of Computer Programs (Video Lectures)
Author(s) : Harold Abelson and Gerald Jay Sussman
Publication Date : 2005
Free License : Creative Commons License

Terms and Conditions:
These video lectures are copyright by Hal Abelson and Gerald Jay Sussman। They are licensed under a Creative Commons License.


View/Download Structure and Interpretation of Computer Programs - Video Lectures .

Structure and Interpretation of Computer Programs

0 comments
The material in The Structure and Interpretation of Computer Programs has been the basis of MIT's entry-level computer science subject since 1980. Most of the students who attend this subject have had little or no prior formal training in computation.

Readers who complete this book should have a good feel for the elements of style and the aesthetics of programming. They should have command of the major techniques for controlling complexity in a large system. They should be capable of reading a 50-page-long program, if it is written in an exemplary style. They should know what not to read, and what they need not understand at any moment. They should feel secure about modifying a program, retaining the spirit and style of the original author.

This book uses Scheme - a dialect of Lisp - but it doesn't formally teach the language. The purpose of this book is not to deal with the syntactic details of the language, but rather to get on with the real issues - figuring out what to compute, how to decompose problems into manageable parts, and how to work on the parts.

Reviews:

Amazon.com

"SICP is an excellent, perhaps the best, advanced introduction to computer science and programming."


Structure and Interpretation of Computer Programs
Author(s) : Harold Abelson, Gerald Jay Sussman and Julie Sussman
Publication date : Jul 1996
ISBN : 0-262-01153-0
Pages : 657
Publisher : The MIT Press


View/Download Structure and Interpretation of Computer Programs

Programming Principles in Java: Architectures and Interfaces

0 comments
In an ever increasing fashion, amateur programmers use visual, drag-and-drop languages to program applications for home, school, and office use. This type of programming will play a crucial role in satisfying the exploding demand for software, but there will always be limits -- just as no hospital patient would submit to a surgery conducted by a someone who never went through a formal training, no customer of a complex or safety-critical system will settle for software written by anyone but a properly trained, professional programmer.

What makes professional programming different from amateur programming? The answer lies in use of structures -- control structures (sequencing, conditionals, iteration, parallelism), data structures (arrays, stacks, trees), and component structures (modules, classes, objects, packages). Professional programmers understand how to employ properly all three forms of structure; amateurs do not. Further, patterns of structures-within-structures define architectures that are learned and regularly imitated by professionals. As indicated by its title, this text presents standard architectures for component construction and patterns of control construction and data construction.

The text takes a 'modern' approach by emphasizing component structures over the other two forms. Computing has matured into a distributed, component-based activity, where both computer hardware and software are assembled from standardized components and connected together by means of standardized interfaces. By no means does this text ignore the classic developments of control and data structures -- they appear in due course at an appropriate level of detail. But component-level issues drive the software design process, and the text emphasizes this fact.

Java is used as the programming language in this text because it supplies solid support for component-structure-driven design; its control and data structuring mechanisms are adequate as well. Because Java and its support library are huge, only a carefully selected subset that promotes sound programming techniques is presented.

Intended Audience:

As the previous narrative indicates, learning to program requires more than merely learning to write in a particular computer language -- reader must understand the structures within programs and how these structures behave. To do this, reader must pore over the book's programming examples, copy them to the computer, test them, try to 'break' or 'trick' them, modify them in small ways, and try them again. In many ways, computer programs are like toys or appliances that can be examined, played with, disassembled, and reassembled in different ways. Experiences like these will help reader to develop programming intuitions.


Programming Principles in Java: Architectures and Interfaces
Author : David Schmidt, Kansas State University
Publication Date : January 2003


View / Download Programming Principles in Java: Architectures and Interfaces

Programming in Oberon - Steps Beyond Pascal

0 comments
This is a book about programming, and in particular about programming in the language of Oberon. It's a language that is defined in terms of relatively few, fundamental programming concepts, rigorously structured, and efficiently implemented on modern computers. These are essentially the same reasons that years ago spoke for the language Pascal. These properties encourage an systematic approach to the designs of the programs, and are the prerequisites for using the essential technique of modular design based on abstraction.

Oberon is a 'small' language which makes it particularly suited as notation for an introduction to programming. Yet its concepts are general and powerful, making it equally appropriate for the construction of large software systems. These claims have been substantiated by the use of Oberon both in teaching and in the design of the Oberon System itself.

Writing a book on programming poses many challenges, in particular how to choose the order in which concepts and constructs are introduced and how to choose examples that are exciting and realistic, yet rely solely on material explained earlier in the text. The book's approach is distinguished in two ways: the procedure and module are introduced early, right after the control structures, and the examples share a common theme: simulation. In the end, a complete and realistic simulation package is obtained.

Intended Audience:

This book is a language reference, a programming tutorial exhibiting modern programming concepts, and implements those concepts in Oberon. This book should therefore serve the professional programmer as well as university professors and students.

The Oberon language was purposefully designed to server as an implementation tool for the Oberon System, an efficient, concise operating system founded on object oriented programming. The language, however, is not tied to the system; its compilers can be provided for any machine under most current operating systems. Programming in Oberon therefore requires no knowledge of the Oberon system, and digress only minimally into the discussion of Oberon system concepts.


Programming in Oberon - Steps Beyond Pascal and Modula
Author(s): Martin Reiser and Niklaus Wirth
Publication Date: 1992
ISBN: 0-201-56543-9
Pages: 320
Publisher: ACM Press, New York; Addison-Wesley Publishing Company
This book was suggested by Kai Koehne


View / Download Programming in Oberon - Steps Beyond Pascal and Modula

Programmed Lessons in Quick Basic

0 comments
These notes are an introduction to computer programming using the language QuickBasic, a version of BASIC that comes free with most Microsoft operating systems. The language BASIC itself was designed in the early 1960s for teaching the basic principles of programming to non-science majors. It has been popular ever since.

With QuickBasic you can easily write small programs and get the idea of what programming is about. Other versions of BASIC are intended for professional programmers who expect to write programs that are many thousands of lines long. Our programs will not get that long.

The twenty-four chapters will give you an idea of what programming is all about. If you faithfully work your way through all the chapters, you will learn how all the gritty details that programming involves add up to the wonderful things called "programs." You will be able to write some simple programs yourself.

These notes are about programming, but they do not try to make you a programmer. Their goal is to increase your understanding of computers in the modern world. If you are thinking about becoming a programmer, studying these notes is a good first step. However, these notes are aimed at students who are not computer science majors. Details have been kept to a minimum.


Programmed Lessons in Quick Basic
Author(s) : Bradley Kjell (Central Connecticut State University)
Publication Date : September 2004


View/Download Programmed Lessons in Quick Basic

Learn to Program Using Python

0 comments
Learning To Program in Python is intended for absolute beginners on web programming. It covers the basic theory of computer programming - what it is, some of its history and the basic techniques needed to solve problems. It doesn't teach esoteric techniques or the details of any particular programming language, in fact it uses several different languages, since it is important to realize that different languages do different things well. That said, the majority of the course is in the language called Python.

The readers are expected to be an experienced users of a computer system, probably MS DOS, Windows or Unix although others should be able to cope too. Which is why this book doesn't cover issues like how to create or copy text files, how to install software, or the organization of files on a computer storage system. They are also expected to understand basic mathematical concepts such as geometric coordinates, sets, and basic algebra.

Python is chosen because it happens to be a nice language to learn. Its syntax is simple and it has some very powerful features built into the language. It supports lots of programming styles from the very simple through to state of the art object oriented techniques. It runs on lots of platforms - Unix/Linux, MS Windows, Macintosh etc. It also has a very friendly and helpful user community. All of these are important features for a beginner's language.

Updates: The book now features VBScript and JavaScript as well as Python as example languages.

Reviews:

Amazon.com

"The tone of the book was perfect for me. It eased me into the world of programming while keeping me rooted in concepts I could relate too. The author is very sympathetic to the needs of readers like me, who are not naturally enclined programmers but need to get into the field."


Learn to Program Using Python
Author(s) : Alan Gauld
Publication date : Jan 2001
ISBN : 0-201-70938-4
Pages : 288
Publisher : Addison-Wesley Pub Co


View/Download Learn to Program Using Python | Spanish | Portuguese | German | Czech | Korean | Italian

Introduction To Programming With Java

0 comments
Introduction To Programming With Java is a free, on-line textbook. It is suitable for use in an introductory programming course and for people who are trying to learn programming on their own. There are no prerequisites beyond a general familiarity with the ideas of computers and programs.

This text uses the Java programming language as the language of instruction। It requires Java version 1.1 or higher. In style, this is a textbook rather than a tutorial. That is, it concentrates on explaining concepts rather than giving step-by-step how-to-do-it guides. It is certainly not a Java reference book, and it is not even a comprehensive survey of all the features of Java. It is not a quick introduction to Java for people who already know another programming language. Instead, it is directed mainly towards people who are learning programming for the first time, and it is as much about general programming concepts as it is about Java in particular.


Introduction To Programming With Java
Author(s) : David J. Eck
Publication date : Feb 2001
Free license : Open Publication License


View/Download Introduction To Programming With Java

Introduction to Computing - Explorations in Language, Logic, and Machines

0 comments
In the past hundred years, computer science has changed the world more than any other field. Without computer science, humans would not have walked on the Moon, modern medicine would not exist, and Wal-Mart would be a small store in Arkansas. But this course is not just about the pragmatic impact of computer science; it is about how computer science changes the ways we think, solve problems and understand the world.

Despite its name, computer science has very little to do with the beige boxes we call computers, and it is far from being a science. It has more in common with music and mathematics than it does with science or engineering. At its core, computer science is the study of imperative knowledge. Whereas mathematics is all about declarative knowledge ("what is"), computer science is all about "how to" knowledge.

Computer science is the study of information processes. Computer scientists study how to describe, predict properties of, and efficiently implement information processes.

Most of what we know about describing information processes stems from three simple ideas:
1. You can define things in terms of themselves (recursive definitions).
2. You can treat procedures and data as one and the same (universality).
3. When you give something a name, it becomes more useful (abstraction).

Although these ideas are simple, they have profound implications that it takes many years to fully appreciate.

The kinds of properties we want to predict about information processes include whether or not there is a procedure that can always solve a given problem (computability), and how much time and space will be required to solve a given problem (complexity)


Introduction to Computing - Explorations in Language, Logic, and Machines
Author : David Evans, Department of Computer Science, University of Virginia
Publication Date : 19 August 2009
License : This work is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 United States License.

About the Book:
This book is used for the course cs120:Introduction to Computing at the Department of Computer Science, University of Virginia.


View/Download Introduction to Computing - Explorations in Language, Logic, and Machines

Introduction to Interactive Programming In Java

0 comments
Interactive Programming is an introduction to computer programming intended for students in standard CS1 courses (or interested professionals) with no prior programming experience. It is the first textbook to rethink the traditional curriculum in light of the current interaction-based computer revolution. Interactive Programming shifts the foundation on which the teaching of Computer Science is based, treating computation as interaction rather than calculation, thus providing students with a solid grounding in the thought that underlies modern software practice. Students still learn the basic and necessary elements of computer programming and the Java language, but the context in which they learn it is more consistent both with Java's tools and philosophy and with the prevailing practice from which it arises.

Interactive Programming provides an alternate entry into the computer science curriculum. It teaches problem decomposition, program design, construction, and evaluation, beginning with the following premises: A program is a community of interacting entities. Its "pieces" are these implicitly or explicitly concurrent entities: user interfaces, databases, network services, etc. They are combined by virtue of ongoing interactions which are constrained by interfaces and by protocols. A program is evaluated by its adherence to a set of invariants, constraints, and service guarantees -- timely response, no memory leaks, etc.

Because it begins from this alternate notion of what programming is about, Interactive Programming tells a rather different story from the traditional introductory programming book. By its end, students are empowered to write and read code for client-server chat programs, networked video games, web servers, user interfaces, and remote interaction protocols. They build event-driven graphical user interfaces and spawn cooperating threads. Each of these programs -- all of which are beyond the scope of traditionally taught introductory courses -- is a natural extension of the community metaphor for computation.

Intended Audience:
This book 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.


Introduction to Programming (in Java) - An Interdisciplinary Approach
Authors : Robert Sedgewick and Kevin Wayne, Department of Computer Science, Princeton University
Publication Date : 2007, preliminary version printed December 1, 2006

Terms and Conditions:
Robert Sedgewick wrote:
For information on obtaining permission for use of material from this work, please submit a request to the authors at rs@cs.princeton.edu and wayne@cs.princeton.edu.


View / Download Interactive Programming In Java