::The eBooks Web Porch
Posted: February 11th, 2008, 5:01pm CET by sruthin
The way of the program
The goal of this book is to teach you to think like a computer scientist. I like the way computer
scientists think because they combine 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. By that I mean
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. That's why this chapter is called "The way of the program."
Of course, the other goal of this book is to prepare you for the Computer Science AP Exam. We
may not take the most direct approach to that goal, though. For example, there are not many
exercises in this book that are similar to the AP questions. On the other hand, if you understand
the concepts in this book, along with the details of programming in C++, you will have all the
tools you need to do well on the exam.
1.1 What is a programming language?
The programming language you will be learning is C++, because that is the language the AP
exam is based on, as of 1998. Before that, the exam used Pascal. Both C++ and Pascal are
high-level languages; other high-level languages you might have heard of are Java, C and
FORTRAN.
As you might infer from the name "high-level language," there are also low-level languages,
sometimes referred to as machine language or assembly language. Loosely-speaking, computers
can only execute programs written in low-level languages. Thus, programs written in a
high-level language have to be translated before they can run. This translation takes some time,
which is a small disadvantage of high-level languages.
But the advantages are enormous. First, it is much easier to program in a high-level language;
by "easier" I mean that the program takes less time to write, it's shorter and easier to read, and
it's more likely to be correct. Secondly, high-level languages are portable, meaning that they
can run on different kinds of computers with few or no modifications. Low-level programs can
only run on one kind of computer, and have to be rewritten to run on another.
Due to these advantages, almost all programs are written in high-level languages. Low-level
languages are only used for a few special applications.
There are two ways to translate a program; interpreting or compiling. An interpreter is a
program that reads a high-level program and does what it says. In effect, it translates the
program line-by-line, alternately reading lines and carrying out commands.
A compiler is a program that reads a high-level program and translates it all at once, before
executing any of the commands. Often you compile the program as a separate step, and then
execute the compiled code later. In this case, the high-level program is called the source code,
and the translated program is called the object code or the executable.
As an example, suppose you write a program in C++. You might use a text editor to write the
program (a text editor is a simple word processor). When the program is finished, you might
save it in a file named program.cpp, where "program" is an arbitrary name you make up, and
the suffix .cpp is a convention that indicates that the file contains C++ source code.
Then, depending on what your programming environment is like, you might leave the text editor
and run the compiler. The compiler would read your source code, translate it, and create a new
file named program.o to contain the object code, or program.exe to contain the executable.
The next step is to run the program, which requires some kind of executor. The role of the
executor is to load the program (copy it from disk into memory) and make the computer start
executing the program.
Although this process may seem complicated, the good news is that in most programming
environments (sometimes called development environments), these steps are automated for
you. Usually you will only have to write a program and type a single command to compile and
run it. On the other hand, it is useful to know what the steps are that are happening in the
background, so that if something goes wrong you can figure out what it is.
How To Think Like A Computer Scientist With C++
Full download
Posted: February 11th, 2008, 4:58pm CET by sruthin
Preface The Qt toolkit is a C++ class library and a set of tools for building multiplatform
GUI programs using a “write once, compile anywhere” approach. Qt lets
programmers use a single source tree for applications that will run on Windows
95 to XP, Mac OS X, Linux, Solaris, HP-UX, and many other versions of
Unix with X11.A version of Qt is also available for Embedded Linux, with the
same API.
The purpose of this book is to teach you how to write GUI programs using Qt 3.
The book starts with “Hello Qt” and quickly moves on to more advanced topics,
such as creating custom widgets and providing drag and drop. The text is
complemented by a CDthat contains the source code of the example programs.
The CD also provides Qt and Borland C++ for Windows, Qt for Unix, and Qt
for Mac OS X. Appendix A explains how to install the software.
The book focuses on explaining good idiomatic Qt 3 programming techniques
rather than simply rehashing or summarizing Qt’s extensive online documentation.
And because we are involved in the development of Qt 4, we have tried
to ensure that most of what we teach here will still be valid and sensible for
Qt 4.
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. In the few places where a more advanced C++ construct is
unavoidable, it is explained as it is used.
Qt made its reputation as a multiplatform toolkit, but because of its intuitive
and powerful API, many organizations use Qt for single-platform development.
Adobe PhotoshopAlbum is just one example of a mass-marketWindows
application written in Qt. Many sophisticated software systems in vertical
markets, such as 3D animation tools, digital film processing, electronic design
automation (for chip design), oil and gas exploration, financial services, and
medical imaging, are built with Qt. If you are making a living with a successful
Windows product written in Qt, you can easily create new markets in the
Mac OS X and Linux worlds simply by recompiling.
Qt is available under various licenses. If you want to build commercial
applications, you must buy a commercial license; if you want to build open
source programs,you can use a non-commercial Qt edition. (The editions of Qt
on the CD are non-commercial.) Qt is the foundation on which the K Desktop
Environment (KDE) and the many open source applications that go with it
are built.
In addition to Qt’s hundreds of classes, there are add-ons that extend Qt’s
scope and power. Some of these products, like the Qt/Motif integration module
and Qt Script for Applications (QSA), are supplied by Trolltech, while others
are provided by companies and by the open source community. See http://
www.trolltech.com/products/3rdparty/ for information on Qt add-ons. Qt also
has a well-established and thriving user community that uses the qt-interest
mailing list; see http://lists.trolltech.com/ for details.
The book is divided into two parts. Part I covers all the concepts and practices
necessary for programming GUI applications using Qt. Knowledge of this
part alone is sufficient to write useful GUI applications. Part II covers central
Qt topics in more depth and provides more specialized and advanced material.
The chapters of Part II can be read in any order, but they assume familiarity
with the contents of Part I.
C++ GUI Programming With Qt 3
Full download
Posted: February 11th, 2008, 1:15am CET by sruthin
Design Patterns in Ruby (c) by Addison-Wesley Professional
The type of the release is: eBook
In the PDF format with ISBN: 0321490452 and Pub Date: December 20, 2007
The size of the release is: 02 disks x 1.44mb
And released on: 02/09/2008
Praise for Design Patterns in Ruby
"Design Patterns in Ruby documents smart ways to resolve many problems that Ruby
developers commonly encounter. Russ Olsen has done a great job of selecting classic patterns
and augmenting these with newer patterns that have special relevance for Ruby. He clearly
explains each idea, making a wealth of experience available to Ruby developers for their own
daily work."
—Steve Metsker, Managing Consultant with Dominion Digital, Inc.
"This book provides a great demonstration of the key 'Gang of Four' design patterns without
resorting to overly technical explanations. Written in a precise, yet almost informal style, this
book covers enough ground that even those without prior exposure to design patterns will soon
feel confident applying them using Ruby. Olsen has done a great job to make a book about a
classically 'dry' subject into such an engaging and even occasionally humorous read."
—Peter Cooper
"This book renewed my interest in understanding patterns after a decade of good intentions.
Russ picked the most useful patterns for Ruby and introduced them in a straightforward and
logical manner, going beyond the GoF's patterns. This book has improved my use of Ruby, and
encouraged me to blow off the dust covering the GoF book."
—Mike Stok
"Design Patterns in Ruby is a great way for programmers from statically typed objectoriented
languages to learn how design patterns appear in a more dynamic, flexible language like Ruby."
—Rob Sanheim, Ruby Ninja, Relevance
Most design pattern books are based on C++ and Java. But Ruby is different—and the language's
unique qualities make design patterns easier to implement and use. In this book, Russ Olsen
demonstrates how to combine Ruby's power and elegance with patterns, and write more
sophisticated, effective software with far fewer lines of code.
After reviewing the history, concepts, and goals of design patterns, Olsen offers a quick tour of
the Ruby language—enough to allow any experienced software developer to immediately utilize
patterns with Ruby. The book especially calls attention to Ruby features that simplify the use of
patterns, including dynamic typing, code closures, and "mixins" for easier code reuse.
Fourteen of the classic "Gang of Four" patterns are considered from the Ruby point of view,
explaining what problems each pattern solves, discussing whether traditional implementations
make sense in the Ruby environment, and introducing Ruby-specific improvements. You'll
discover opportunities to implement patterns in just one or two lines of code, instead of the
endlessly repeated boilerplate that conventional languages often require.
Design Patterns in Ruby also identifies innovative new patterns that have emerged from the
Ruby community. These include ways to create custom objects with metaprogramming, as well
as the ambitious Rails-based "Convention Over Configuration" pattern, designed to help
integrate entire applications and frameworks.
Engaging, practical, and accessible, Design Patterns in Ruby will help you build better software
while making your Ruby programming experience more rewarding.
http://www.amazon.com/exec/obidos/tg/detail/-/0321490452/
Download This
Full download
Posted: February 11th, 2008, 1:06am CET by sruthin
Implementation Patterns (c) by Addison-Wesley Professional
The type of the release is: eBook
In the PDF format with ISBN: 0321413091 and Pub Date: November 02, 2007
The size of the release is: 01 disks x 1.44mb
And released on: 02/09/2008
“Kent is a master at creating code that communicates well, is easy to understand, and is a
pleasure to read. Every chapter of this book contains excellent explanations and insights into the
smaller but important decisions we continuously have to make when creating quality code and
classes.”
–Erich Gamma, IBM Distinguished Engineer
“Many teams have a master developer who makes a rapid stream of good decisions all day long.
Their code is easy to understand, quick to modify, and feels safe and comfortable to work with. If
you ask how they thought to write something the way they did, they always have a good reason.
This book will help you become the master developer on your team. The breadth and depth of
topics will engage veteran programmers, who will pick up new tricks and improve on old habits,
while the clarity makes it accessible to even novice developers.”
–Russ Rufer, Silicon Valley Patterns Group
“Many people don’t realize how readable code can be and how valuable that readability is. Kent
has taught me so much, I’m glad this book gives everyone the chance to learn from him.”
–Martin Fowler, chief scientist, ThoughtWorks
“Code should be worth reading, not just by the compiler, but by humans. Kent Beck distilled his
experience into a cohesive collection of implementation patterns. These nuggets of advice will
make your code truly worth reading.”
–Gregor Hohpe, author of Enterprise Integration Patterns
“In this book Kent Beck shows how writing clear and readable code follows from the application
of simple principles. Implementation Patterns will help developers write intention revealing code
that is both easy to understand and flexible towards future extensions. A must read for
developers who are serious about their code.”
–Sven Gorts
“Implementation Patterns bridges the gap between design and coding. Beck introduces a new
way of thinking about programming by basing his discussion on values and principles.”
–Diomidis Spinellis, author of Code Reading and Code Quality
Software Expert Kent Beck Presents a Catalog of Patterns Infinitely Useful for Everyday
Programming
Great code doesn’t just function: it clearly and consistently communicates your intentions,
allowing other programmers to understand your code, rely on it, and modify it with confidence.
But great code doesn’t just happen. It is the outcome of hundreds of small but critical decisions
programmers make every single day. Now, legendary software innovator Kent Beck–known
worldwide for creating Extreme Programming and pioneering software patterns and test-driven
development–focuses on these critical decisions, unearthing powerful “implementation patterns”
for writing programs that are simpler, clearer, better organized, and more cost effective.
Beck collects 77 patterns for handling everyday programming tasks and writing more readable
code. This new collection of patterns addresses many aspects of development, including class,
state, behavior, method, collections, frameworks, and more. He uses diagrams, stories,
examples, and essays to engage the reader as he illuminates the patterns. You’ll find proven
solutions for handling everything from naming variables to checking exceptions.
This book covers
The value of communicating through code and the philosophy behind patterns
How and when to create classes, and how classes encode logic
Best practices for storing and retrieving state
Behavior: patterns for representing logic, including alternative paths
Writing, naming, and decomposing methods
Choosing and using collections
Implementation pattern variations for use in building frameworks
Implementation Patterns will help programmers at all experience levels, especially those who
have benefited from software patterns or agile methods. It will also be an indispensable resource
for development teams seeking to work together more efficiently and build more maintainable
software. No other programming book will touch your day-to-day work more often.
http://www.amazon.com/exec/obidos/tg/detail/-/0321413091/
Download This
Full download
