Thứ Ba, 24 tháng 3, 2015
Wesley Professional Spring Into Linux (2005)
This book is meant for computer users who are new to Linux. Your understanding of computer concepts and experience with other operation system allows you grasp the Linux information quickly . You do not need to be told how to press the power switch. You are way beyond this. You can get your work done on Windows (or Mac or UNIX); you just need a quick start guide for working on Linux.
It is not impossible to learn Linux from this book without a background in computer just difficult. The book assumes an understanding of concepts and computer use that you may not possess. However, If you appreciate a book that assumes you can understand quickly and delivers information in a compact form, without distractions and repetitive explanations, give this one a try. It might work for you.
DOWNLOAD
http://adf.ly/1BaPHt
Professional Linux Kernel Development 3rd (2010)
A s the Linux kernel and the applications that use it become more widely used, we are
seeing an increasing number of system software developers who wish to become involved
in the development and maintenance of Linux. Some of these engineers are motivated
purely by personal interest, some work for Linux companies, some work for hardware
manufacturers, and some are involved with in-house development projects.
But all face a common problem:The learning curve for the kernel is getting longer
and steeper.The system is becoming increasingly complex, and it is very large.And as the
years pass, the current members of the kernel development team gain deeper and broader
knowledge of the kernel’s internals, which widens the gap between them and newcomers.
I believe that this declining accessibility of the Linux source base is already a problem
for the quality of the kernel, and it will become more serious over time.Those who care
for Linux clearly have an interest in increasing the number of developers who can con-
tribute to the kernel.
One approach to this problem is to keep the code clean: sensible interfaces, consistent
layout,“do one thing, do it well,” and so on.This is Linus Torvalds’ solution.
The approach that I counsel is to liberally apply commentary to the code: words that
the reader can use to understand what the coder intended to achieve at the time. (The
process of identifying divergences between the intent and the implementation is known
as debugging. It is hard to do this if the intent is not known.)
But even code commentary does not provide the broad-sweep view of what a major
subsystem is intended to do, and of how its developers set about doing it.This, the start-
ing point of understanding, is what the written word serves best.
Robert Love’s contribution provides a means by which experienced developers can
gain that essential view of what services the kernel subsystems are supposed to provide,
and of how they set about providing them.This will be sufficient knowledge for many
people: the curious, the application developers, those who wish to evaluate the kernel’s
design, and others.
But the book is also a stepping stone to take aspiring kernel developers to the next
stage, which is making alterations to the kernel to achieve some defined objective. I
would encourage aspiring developers to get their hands dirty:The best way to under-
stand a part of the kernel is to make changes to it. Making a change forces the developer
to a level of understanding which merely reading the code does not provide.The serious
kernel developer will join the development mailing lists and will interact with other
developers.This interaction is the primary means by which kernel contributors learnand stay abreast. Robert covers the mechanics and culture of this important part of
kernel life well.
Please enjoy and learn from Robert’s book.And should you decide to take the next
step and become a member of the kernel development community, consider yourself
welcomed in advance.We value and measure people by the usefulness of their contribu-
tions, and when you contribute to Linux, you do so in the knowledge that your work is
of small but immediate benefit to tens or even hundreds of millions of human beings.
This is a most enjoyable privilege and responsibility.
DOWNLOAD LINK
http://adf.ly/1BaNKS
Multicore Application Programming, For Windows Linux and Oracle Solaris (2011)
Structure of This Book
This book is divided into the following chapters.
Chapter 1 introduces the hardware and software concepts that will be encountered
in the rest of the book. The chapter gives an overview of the internals of processors. It is
not necessarily critical for the reader to understand how hardware works before they can
write programs that utilize multicore systems. However, an understanding of the basics of
processor architecture will enable the reader to better understand some of the concepts
relating to application correctness, performance, and scaling that are presented later in
the book. The chapter also discusses the concepts of threads and processes.
Chapter 2 discusses profiling and optimizing applications. One of the book’s prem-
ises is that it is vital to understand where the application currently spends its time before
work is spent on modifying the application to use multiple cores. The chapter covers all
the leading contributors to performance over the application development cycle and dis-
cusses how performance can be improved.
Chapter 3 describes ways that multicore systems can be used to perform more work
per unit time or reduce the amount of time it takes to complete a single unit of work. It
starts with a discussion of virtualization where one new system can be used to replace
multiple older systems. This consolidation can be achieved with no change in the soft-
ware. It is important to realize that multicore systems represent an opportunity to change
the way an application works; they do not require that the application be changed. The
chapter continues with describing various patterns that can be used to write parallel
applications and discusses the situations when these patterns might be useful.
Chapter 4 describes sharing data safely between multiple threads. The chapter leads
with a discussion of data races, the most common type of correctness problem encoun-
tered in multithreaded codes. This chapter covers how to safely share data and synchro-
nize threads at an abstract level of detail. The subsequent chapters describe the operating
system–specific details.
Chapter 5 describes writing parallel applications using POSIX threads. This is the
standard implemented by UNIX-like operating systems, such as Linux, Apple’s OS X,
and Oracle’s Solaris. The POSIX threading library provides a number of useful building
blocks for writing parallel applications. It offers great flexibility and ease of development.
Chapter 6 describes writing parallel applications for Microsoft Windows using
Windows native threading. Windows provides similar synchronization and data sharing
primitives to those provided by POSIX. The differences are in the interfaces and require-
ments of these functions.
Chapter 7 describes opportunities and limitations of automatic parallelization pro-
vided by compilers. The chapter also covers the OpenMP specification, which makes it
relatively straightforward to write applications that take advantage of multicore processors.
Chapter 8 discusses how to write parallel applications without using the functional-
ity in libraries provided by the operating system or compiler. There are some good rea-
sons for writing custom code for synchronization or sharing of data. These might be forfiner control or potentially better performance. However, there are a number of pitfalls
that need to be avoided in producing code that functions correctly.
Chapter 9 discusses how applications can be improved to scale in such a way as to
maximize the work performed by a multicore system. The chapter describes the common
areas where scaling might be limited and also describes ways that these scaling limitations
can be identified. It is in the scaling that developing for a multicore system is differenti-
ated from developing for a multiprocessor system; this chapter discusses the areas where
the implementation of the hardware will make a difference.
Chapter 10 covers a number of alternative approaches to writing parallel applica-
tions. As multicore processors become mainstream, other approaches are being tried to
overcome some of the hurdles of writing correct, fast, and scalable parallel code.
Chapter 11 concludes the book.
xviii Preface
DOWNLOAD LINK
http://adf.ly/1BaHWl0
Moving to Ubuntu Linux
To the newcomer, the computer world can seem pretty forbidding. The
secret codes for operating these metal beasts are under the control of myste-
rious geeks who speak some language that sounds like English but makes no
sense. Even if you manage to master some corner of the computer contin-
uum, the rug can be pulled out from under you without warning. A program
that seemed tame will suddenly grow fangs. The way you’ve been doing
things for months will stop working without notice.
Once you’ve managed to tame the beast even a little it seems like mas-
ochism to consider switching to another operating system, but for many of us
who use, and suffer with, Windows, the choice to continue to use that spawn
of Microsoft may seem masochistic, too.
Spyware, viruses, blue screens of death, confused user interfaces, buggy
programs, security flaws, the list of problems with Windows seems endless.
Many Windows users wonder if there’s a better way, but dread the idea of
learning to tame another beast.
Well, as Marcel Gagné has been showing us for years in his superb books,
his “Cooking with Linux” columns, and on my TV show, Call for Help, there
is a better way, and it’s called Linux. Until recently Linux was the choice of
cellar-dwelling computer geeks and four-eyed server administrators. The idea
of a normal person using Linux on his or her desktop for day-to-day work was
far-fetched to say the least. All that is changing, due in part to the success of
Ubuntu Linux.
DOWNLOAD LINK
http://adf.ly/1BaBQM
Open Source Web Development with LAMP
software for building dynamic, data-driven Web applications. This practical guide presents a comprehensive survey of LAMP (Linux,
Apache, MySQL, Perl, and PHP), and it shows how these solutions can be implemented efficiently and securely while improving
reliability and dramatically cutting costs.
Open Source Web Development with LAMP focuses on the most important core material necessary so that developers can "hit the
ground running" and begin building applications right away. This book presents a balanced overview of LAMP technologies and allows
the reader to decide which tool may be appropriate for the particular task at hand. After a general overview of Open Source technologies,
the book presents an overview of the Web before moving on to cover structural, static, dynamic, and embedded technologies. The
coverage here provides a description of the strengths and weaknesses of each Open Source technology and also acts as a reference
guide for each application.
DOWNLOAD LINK
http://adf.ly/1Ba8WU