In Search of Stupidity or GCC Book

In Search of Stupidity: Over 20 Years of High-Tech Marketing Disasters

Author: Merrill R Chapman

In Search of Stupidity: Over Twenty Years of High-Tech Marketing Disasters, Second Edition is National Lampoon meets Peter Drucker. It's a funny and well-written business book that takes a look at some of the most influential marketing and business philosophies of the last twenty years. Through the dark glass of hindsight, it provides an educational and entertaining look at why these philosophies didn't work for many of the country's largest and best-known high-tech companies.

Marketing wizard Richard Chapman takes you on a hilarious ride in this book, which is richly illustrated with cartoons and reproductions of many of the actual campaigns used at the time. Filled with personal anecdotes spanning Chapman's remarkable career (he was present at many now-famous meetings and events), In Search of Stupidity, Second Edition examines the best of the worst marketing ideas and business decisions in the last twenty years of the technology industry.

The second edition includes new chapters on Google and on how to avoid stupidity, plus the extensive analyses of all chapters from the first edition. You'll want to get a copy because it

• Features an interesting preface and interview with Joel Spolsky of "Joel on Software"
• Offers practical advice on avoiding PR disaster
• Features actual pictures of some of the worst PR and marketing material ever created
• Is highly readable and funny
• Includes theme-based cartoons for every chapter

Slashdot.org
An excellent source of information, analysis and good laughs. It's one of the few industry titles that will give you a large supply of stories to re-tell to other developers over a beer. Chapman's book is also an excellent case study collection of anti-management rules that one should avoid when running a high tech company.

Book about: Politica sporca: Inganno, distrazione e democrazia

GCC Book

Author: Kurt Wall

The Definitive Guide to GCC is a comprehensive tutorial and guide to using the newest version of GCC, the GNU Compiler Collection. GCC is quite simply the most used and most powerful tool for programmers on the planet. GCC has long been available for most major hardware and operating system platforms and is often the preferred compiler for those platforms. As a general-purpose compiler, GCC produces higher quality, faster performing executable code with fewer bugs than equivalent offerings supplied by hardware and software vendors. GCC, along with GNU Emacs, the Linux operating system, the Apache web server, the Sendmail mail server, and the BIND DNS server, is one of the showpieces of the free software world and proof that sometimes you can get a free lunch.

In The Definitive Guide to GCC, authors William von Hagen and Kurt Wall teach you how to build, install, customize, use, and troubleshoot GCC 3.2. This guide goes beyond just command-line invocations to show you how to use GCC to improve the quality of your code (with debugging, code profiling, and test code coverage), and how to integrate other GNU development tools, such as libtool, automake, and autoconf, into your GCC-based development projects.

Table of Contents:

	About the Authors
	About the Technical Reviewer
	Acknowledgments
	Introducing GCC and the Definitive Guide to GCC
Ch. 1	Building GCC	1
Ch. 2	Installing GCC on DOS and Windows Platforms	39
Ch. 3	Basic GCC Usage	59
Ch. 4	Advanced GCC Usage	101
Ch. 5	Optimizing Code with GCC	135
Ch. 6	Performing Code Analysis with GCC	147
Ch. 7	Using Autoconf and Automake	187
Ch. 8	Using Libtool	221
Ch. 9	Troubleshooting GCC	245
Ch. 10	Using GCC's Online Help	265
Ch. 11	GCC Command-Line Options	283
Ch. 12	Additional GCC Resources	347
App. A	Building and Installing Glibc	363
App. B	Machine and Processor-Specific Options for GCC	403
	Index	497

Introduction to Software Testing or Programming with QT

Introduction to Software Testing

Author: Paul Ammann

Extensively class tested, this text takes an innovative approach to explaining the process of software testing: it defines testing as the process of applying a few well-defined, general-purpose test criteria to a structure or model of the software. The structure of the text directly reflects the pedagogical approach and incorporates the latest innovations in testing, including techniques to test modern types of software such as OO, web applications, and embedded software.

Table of Contents:

List of Figures     ix
List of Tables     xiii
Preface     xv
Overview     1
Introduction     3
Activities of a Test Engineer     4
Testing Levels Based on Software Activity     5
Beizer's Testing Levels Based on Test Process Maturity     8
Automation of Test Activities     10
Software Testing Limitations and Terminology     11
Coverage Criteria for Testing     16
Infeasibility and Subsumption     20
Characteristics of a Good Coverage Criterion     20
Older Software Testing Terminology     21
Bibliographic Notes     22
Coverage Criteria     25
Graph Coverage     27
Overview     27
Graph Coverage Criteria     32
Structural Coverage Criteria     33
Data Flow Criteria     44
Subsumption Relationships among Graph Coverage Criteria     50
Graph Coverage for Source Code     52
Structural Graph Coverage for Source Code     52
Data Flow Graph Coverage for Source Code     54
Graph Coverage for Design Elements     65
Structural Graph Coverage for Design Elements     65
Data Flow Graph Coverage for Design Elements     67
Graph Coverage for Specifications     75
Testing Sequencing Constraints     75
Testing State Behavior of Software     77
Graph Coverage for Use Cases     87
Use Case Scenarios     90
Representing Graphs Algebraically     91
Reducing Graphs to Path Expressions     94
Applications of Path Expressions     96
Deriving Test Inputs     96
Counting Paths in a Flow Graph and Determining Max Path Length     97
Minimum Number of Paths to Reach All Edges     98
Complementary Operations Analysis     98
Bibliographic Notes     100
Logic Coverage     104
Overview: Logic Predicates and Clauses     104
Logic Expression Coverage Criteria     106
Active Clause Coverage     107
Inactive Clause Coverage     111
Infeasibility and Subsumption     112
Making a Clause Determine a Predicate     113
Finding Satisfying Values     115
Structural Logic Coverage of Programs     120
Predicate Transformation Issues     127
Specification-Based Logic Coverage     131
Logic Coverage of Finite State Machines     134
Disjunctive Normal Form Criteria     138
Bibliographic Notes     147
Input Space Partitioning     150
Input Domain Modeling     152
Interface-Based Input domain Modeling     153
Functionality-Based Input Domain Modeling     154
Identifying Characteristics     154
Choosing Blocks and Values     156
Using More than One Input Domain Model     158
Checking the Input Domain Model     158
Combination Strategies Criteria     160
Constraints among Partitions     165
Bibliographic Notes     166
Syntax-Based Testing     170
Syntax-Based Coverage Criteria     170
BNF Coverage Criteria     170
Mutation Testing     173
Program-Based Grammars     176
BNF Grammars for Languages     176
Program-Based Mutation     176
Integration and Object-Oriented Testing     191
BNF Integration Testing     192
Integration Mutation     192
Specification-Based Grammars     197
BNF Grammars     198
Specification-Based Mutation     198
Input Space Grammars     201
BNF Grammars     201
Mutation for Input Grammars     204
Bibliographic Notes     210
Applying Criteria in Practice     213
Practical Considerations     215
Regression Testing     215
Integration and Testing     217
Stubs and Drivers     218
Class Integration Test Order     218
Test Process     219
Requirements Analysis and Specification     220
System and Software Design     221
Intermediate Design     222
Detailed Design     223
Implementation     223
Integration     224
System Deployment     224
Operation and Maintenance     224
Summary     225
Test Plans     225
Identifying Correct Outputs     230
Direct Verification of Outputs     230
Redundant Computations     231
Consistency Checks     231
Data Redundancy     232
Bibliographic Notes     233
Engineering Criteria for Technologies     235
Testing Object-Oriented Software     236
Unique Issues with Testing OO Software      237
Types of Object-Oriented Faults     237
Testing Web Applications and Web Services     256
Testing Static Hyper Text Web Sites     257
Testing Dynamic Web Applications     257
Testing Web Services     260
Testing Graphical User Interfaces     260
Testing GUIs     261
Real-Time Software and Embedded Software     262
Bibliographic Notes     265
Building Testing Tools     268
Instrumentation for Graph and Logical Expression Criteria     268
Node and Edge Coverage     268
Data Flow Coverage     271
Logic Coverage     272
Building Mutation Testing Tools     272
The Interpretation Approach     274
The Separate Compilation Approach     274
The Schema-Based Approach     275
Using Java Reflection     276
Implementing a Modern Mutation System     277
Bibliographic Notes     277
Challenges in Testing Software     280
Testing for Emergent Properties: Safety and Security     280
Classes of Test Cases for Emergent Properties     283
Software Testability     284
Testability for Common Technologies      285
Test Criteria and the Future of Software Testing     286
Going Forward with Testing Research     288
Bibliographic Notes     290
List of Criteria     293
Bibliography     295
Index     319

Interesting book: Project Study Guide or IPsec Virtual Private Network Fundamentals

Programming with QT: Writing Portable GUI Applications on Unix and Win32

Author: Matthias Kalle Dalheimer

Qt is a C++ class library for writing GUI applications that run on UNIX, Windows 95/98, and Windows NT platforms. Qt is much easier to use than the standard Motif toolkit for UNIX systems, but at the same time Qt emulates the look-and-feel of Motif. Best of all, after you have written an application with Qt, all you have to do is recompile it to have a version that works on Windows systems. Qt also emulates the look-and-feel of Windows, so you can provide all of your users with native-looking interfaces.

Platform independence is not the only benefit of Qt. Qt uses an ingenious signal/slot mechanism for connecting user interaction with program functionality, providing an excellent framework for component-based programming. Graphical rendering in Qt is highly optimized due to its use of effective caching mechanisms -- rendering in Qt is often faster than with the similar native API. In addition to user interface classes, Qt features portable support for file system access, working with date and time values, and network programming. With Qt, you'll find that you need to write very little, if any, platform-dependent code because Qt already has what you need.

Qt is popular with open-source and Linux developers because it can be used for free on UNIX systems for this type of development. For commercial development, you need a license for Qt, which is available from Troll Tech, the developers of Qt. In addition to open-source development, Qt is being used by several major companies and government and international agencies.

While programming with Qt is straightforward and feels natural once you get the hang of it, the learning curve can be steep. Qt comes with excellent reference documentation, but beginners often find the included tutorial is not enough to really get started with Qt. That is where this book steps in. Programming with Qt guides you through the steps of writing a Qt application by showing you how to write a simple paint application. It also helps deepen your understanding of the topics with exercises and fully worked out answers. The book presents all of the GUI elements in Qt, along with advice about when and how to use them, so that you can make full use of the toolkit. There's also lots of information for seasoned Qt programmers, including material on advanced 2D transformations, drag-and-drop, and writing custom image file filters.

Programming with Qt helps you get the most out of Qt. With it, you'll learn to take full advantage of this powerful, easy-to-use, cross-platform toolkit.

Electronic Review of Books - Lou Grinzo

Linux's meteoric rise in both popularity and usage is increasing the demand for solid information for programmers about all aspects of Linux development, as well as cross-platform issues. Programming with Qt, by Matthias Dalheimer, covers a tool that addresses some of the thornier topics in modern GUI programming, cross-platform application frameworks, and widget toolkits. Qt is a product of Troll Tech, and is available for both X Windows and Win32 environments. Dalheimer is a member of the board of directors of the KDE Foundation, and has considerable Qt experience, since the KDE desktop environment for Linux is based on Qt.

In the book's 25 chapters, Dalheimer provides a good overview of the Qt programming model, and presents a solid conceptual framework for any experienced programmer new to Qt. He includes several usage tips and many pieces of thoughtful advice, any one of which could easily be worth the cost of the book in the right circumstances. He also talks about some more advanced topics, such as how to deal with resizable dialogs, especially at a time when large monitors are nearly ubiquitous; portability issues; and even the pros and cons of various approaches to writing a cross-platform widget toolkit like Qt. For readers new to Qt, especially those with a Windows background, this is all useful and enlightening material.

Dalheimer takes you through the expected steps, from the obligatory "Hello, world!" program to dealing with menus, event handling, Qt's layout managers and container classes, graphics and text programming, file handling, focus issues, and interapplication communication. One of the longer chapters covers writing your own Qt widgets, and includes two extended examples that will be useful references for anyone taking on this task. Chapter 9 is one of the strongest parts of the book, in that it covers numerous graphics programming topics, such as palette management, saving and displaying graphics, double buffering, and transformations.

One area the author focuses on throughout the book, and to good effect, is Qt's use of signals and slots. (These are not traditional UNIX IPC signals, but a variation unique to Qt.) This is the technology that notifies specific parts of a program when UI events happen, such as users clicking on a button or an item in a listbox. Every application framework has its own way of performing this "plumbing," and understanding it well enough to get notifications in the right places, forward them effectively, and so on, is critical to using the framework. Dalheimer clearly appreciates this fact, and doesn't just talk about Qt's signals and slots once and then move on, but returns to the topic several times in different contexts.

Experienced programmers might raise an eyebrow over the thought of covering all this material -- an entire application framework and a widget toolkit -- in a mere 361 pages. (Petzold's Programming Windows, easily the standard in this area, is well over twice the page count in its second edition, for example, even if it does cover some topics not in Qt.) This highlights the only serious problem with this book: Its treatment of some topics is conspicuously thin. For example, the discussion of the file open/save dialogs is barely half a page of text (not counting illustrations), yet you will likely spend considerable time with these dialogs in various programs, using them in different ways. This book isn't meant to be a replacement for Troll Tech's reference manual, obviously, but several examples of how to use these dialogs with various options (multiple selection, file must exist, and the like), as well as a discussion of cross-platform issues would have been very welcome. Similarly, there are places where Dalheimer leaves pertinent questions unanswered, such as what the limit is on the number of items that a Qt listbox will handle. (He does advise against putting too many items into a listbox, for human factors reasons, which is clearly good advice, but it's critical for programmers to know what such limits are if they're to avoid exceeding them.)

I was bothered by the number of extremely short chapters. Chapter 13, "Working with Date and Time Values" is less than one page of text, Chapter 18, "Debugging" is not quite two full pages, and "Sample Qt Projects" mentions only two -- KDE and Ortho Vista -- and doesn't provide nearly the insight into real-world usage of Qt for commercial work that I'd hoped for. More serious yet is the book's almost complete avoidance of font and text output issues, something nearly all programmers will have to wrestle with.

These problems certainly don't make this a bad book, but they do make me wish for at least a few hundred more pages of the kind of work that Dalheimer is clearly capable of, to provide the fuller treatment programmers need of Qt at this time. Still, Programming with Qt, combined with the Qt reference material (freely available from the Troll Tech web site), should be enough to get experienced programmers started, while we hold out hope for a more comprehensive second edition.

Web Design or Financial Applications using Excel Add in Development in C C

Web Design: The L Line, The Express Line to Learning

Author: Sue Jenkins

Get on the fast track to creating your own Web site


Want to create a compelling Web site for a home business, family, or fun? Whether you're a student, aspiring designer, or entrepreneur, you can -- with Dreamweaver(r) and this easy-to-follow guide. Gain solid skills as you go from station to station in a series of clear-cut tutorials that cover site planning, registering a domain, formatting, and more. The last stop? Put your new site online and go live! Start your journey today on The L Line.
* Define your goals and create a site plan
* Learn the best ways to combine HTML and Cascading Style Sheets
* Use layers, create forms, and make the site interactive
* Master Web standards and the latest search engine optimization techniques

All aboard for valuable online extras

Visit The L Line Web site at wiley.com/go/thelline for valuable online supplementary materials:
* Test bank with challenging review questions
* PowerPoint slides with chapter outlines
* Images and Web page files from the book
* Practice exam answers
* A CSS reference guide

Along The L Line
* Complete tutorial coverage with step-by-step instruction
* Ample illustrations and examples
* Real-world case studies, applications, and hints for avoiding pitfalls
* Practice exams that let you evaluate your progress

Table of Contents:

Preface     xvii
Starting with a Plan     1
Determining the Site's Purpose     3
Keeping up with the competition     3
Gathering Information     4
Developing a purpose statement     4
Defining the Benefits to Visitors     6
Discovering the true benefits     6
Seeing the visitor's perspective     7
Constructing an Image for the Site     9
Determining Site Content Requirements     10
The bare minimum     11
Marketing and sales content     13
Diagnosing a Site's Dynamic Needs     17
Defining Ways to Drive Traffic to a Site     19
E-newsletters     19
Tips and articles     21
Blogs     22
Polls     26
Calculators     26
Contests and Sweepstakes     28
Defining Your Audience     33
Understanding Market Research     36
Gathering Internet Usage Statistics     37
Looking at Competitors' Web Sites     38
Describing the Ideal Site Visitor     42
Planning for a Multilanguage Site     45
Understanding the options for organizing content     46
Choosing an organization method     48
Translating a site's content     50
Pulling Together the Content     55
Discovering a Site's Content Needs     57
Wireframes     60
Gathering all the written content     64
Hiring illustrators and photographers     64
Licensing and buying stock images     65
Page titles and Meta tag data     66
Organizing Site Content     68
Making the Site Map     70
Choosing Development Tools and Techniques     77
Working with Page-Creation Tools     79
HTML and Web-editing programs     80
Introducing HTML tags     81
Understanding basic HTML page structure     82
Creating a page in a text editor     83
Saving Web page files     84
Working with the Right Design Tools     85
Choosing graphics programs     86
Using Web-safe colors     88
Introducing hexadecimal color values     89
Looking up hexadecimal values in a graphics program     90
Adding an E-Commerce Shopping Cart     93
PayPal shopping carts     93
Third-party and Web host shopping carts      94
Custom-built shopping carts     94
Planning for secure transactions     95
Knowing When to Hire a Programmer     96
Registering a Domain and Getting a Hosting Plan     103
Choosing a Domain Name     105
Using a domain name generator     108
Verifying domain name availability     109
Registering a Domain     110
Finding a Good Hosting Plan     112
Adding a Custom Placeholder Page     115
Designing the page     116
Putting the placeholder page on the Web     122
Defining the Site's Look and Feel     127
Beginning with Target Audience Data     129
Making Basic Layout and Design Decisions     131
Setting the layout width     132
Choosing layout expandability and orientation     133
Choosing a method for printing the layout     136
Choosing a color palette     136
Choosing fonts for the layout     138
Selecting a Navigation Scheme     140
Outlining a Design's Look and Feel     144
Mocking Up the Design     149
Understanding the Value of a Mockup     151
Working from the Site Map     152
Creating the Mockup      153
Strategically Placing Mockup Elements     160
Adding Design Elements to the Mockup     161
Finalizing a Mockup     166
Showing the subnavigation (or rollover)     166
Presenting a mockup to a client     167
Designing Additional Web Site Graphics     169
Header graphics     169
Rollover graphics     169
Background images     172
Other images     172
Optimizing Graphics     177
Understanding Web Graphics     179
Selecting a Web Optimization Program     186
Optimizing Graphics with ImageReady     187
Picking the Right Web Format     189
Choosing Web Optimization Settings     192
GIF and PNG-8 Optimization     194
JPG optimization     196
Slicing Up Graphics     197
Optimization Output Options     204
Working with Web Standards (HTML/XHTML/CSS/508)     209
Following Web Standards     211
Learning about standards online     212
Learning Web site content     214
Using DOCTYPEs (DTDs)     216
Setting the DOCTYPE     216
Adding a DOCTYPE in Dreamweaver      218
Writing HTML and XHTML Code     220
Using CSS Instead of HTML     222
Learning about Accessibility Standards     228
Understanding the HTML accessibility standards     229
Using Dreamweaver's accessibility tools     232
Using Search Engine Optimization Techniques     237
Practicing Ethical SEO Techniques     239
Including Ethical SEO Techniques in Web Pages     241
Maximizing the impact of relevant keywords     241
Embedding object and image descriptions     243
Including description and keywords Meta tags     244
Writing unique page titles     245
Submitting a Web address to search tools     245
Using an HTML Site Map     249
Creating the HTML site map     251
Making the site map accessible     253
Building Basic Pages     261
Setting Up the Basic HTML Skeleton     263
Understanding Meta Tags     266
Adding Content to Pages     271
Text     272
Graphics     274
Lists     278
Tables     280
Creating Hyperlinks     287
Local and global links     287
Link targets     288
Linking images     288
Other link types     290
Semantic HTML Coding     293
Labeling Objects     295
Improving Page Accessibility     296
Page Formatting with CSS     303
Learning about CSS     306
Anatomy of a style     306
Inline, internal, and external CSS     308
Linking external CSS to a page     310
Setting CSS media types     311
Linking external CSS and setting media types in Dreamweaver     314
CSS Style Selectors     315
Applying styles selectively with custom class     315
Redefining tag defaults     316
Morphing other page elements with advanced selectors     317
The Eight Style Categories     319
Formatting with CSS     321
Finding Additional CSS Help     324
Creating Navigation Systems     329
Considering the Site's Organization and Audience     331
Learning about Navigation Systems     332
Creating a Text Navigation Menu     335
Creating a Rollover Button Graphic Navigation Menu     338
Outputting rollovers in ImageReady     340
Creating rollovers in Dreamweaver     343
Creating a Tiered Text-Based JavaScript Navigation Menu     345
Creating a CSS List Navigation Menu     349
Layers- versus Tables-based Layouts     359
Tables versus Layers     362
Creating a Layout with Tables     365
Creating a Layout with Layers     370
Using Layout Resources for CSS and Layers     377
Using Templates and Server-Side Includes (SSIs)     383
Using Dreamweaver Templates     386
Preparing a page to become a template     387
Converting an HTML/XHTML file into a template     388
Creating and editing template-based files     392
Working with Server-Side Includes     393
Creating, including, and testing SSIs     395
Editing paths to work with SSIs     398
Comparing Templates and SSIs     401
Creating Forms     405
Organizing Visitor Information     407
Encrypting and Processing Form Data     409
Building Web Forms     412
Validating Forms     418
Testing Validated Forms     422
Making the Site Interactive     427
Exploring the World of JavaScript     430
Creating multiple rollover effects     432
Launching a new browser window     436
Building complex image maps     440
Adding Multimedia Files     443
Increasing Visitor Interactivity     445
A daily tip     447
Daily Sudoku     450
Testing, Testing, Testing     457
Setting Up a Prelaunch Testing Method     459
Cleaning Up Code     460
Finding and replacing global errors     461
Checking spelling     463
Cleaning up unwanted formatting     465
Cleaning up HTML/XHTML syntax     466
Applying consistent code formatting     467
Checking the Code for Common Problems     468
Validating the markup     469
Checking for browser support     470
Checking links     471
Generating site reports     472
Testing Web Pages on Different Platforms and Browsers     473
Code Validation and Compliance     481
Keeping Syntax Consistent with the Couvert Syntax Tool     483
Validating CSS, HTML, and More with Online Tools     486
Fixing Noncompliant Code     491
Fixing common coding mistakes     491
Retesting and failing acceptably     493
Obtaining Proof of Validation     495
Taking the Site to the Web     499
Uploading with File Transfer Protocol     501
Choosing an FTP application     502
Setting up a remote connection     504
Publishing a Site     507
Setting up a test directory     508
Getting and putting files     509
Testing one last time     511
Finishing the site publication     514
Contacting Search Engines     515
What's Next?     516
CSS Attributes     A-1
Exam Answer Appendix     B-1
Index     521

See also: Against the Grain or Mind Body Therapy

Financial Applications using Excel Add-in Development in C/C++

Author: Steve Dalton

Financial Applications using Excel Add-in Development in C/C++ is a must-buy book for any serious Excel developer.Excel is the industry standard for financial modelling, providing a number of ways for users to extend the functionality of their own add-ins, including VBA and C/C++. This is the only complete how-to guide and reference book for the creation of high performance add-ins for Excel in C and C++ for users in the finance industry. Steve Dalton explains how to apply Excel add-ins to financial applications with many examples given throughout the book. It also covers the relative strengths and weaknesses of developing add-ins for Excel in VBA versus C/C++, and provides comprehensive code, workbooks and example projects on the accompanying CD-ROM. The impact of Excel 2007’s multi-threaded workbook calculations and large grids on add-in development are fully explored. Financial Applications using Excel Add-in Development in C/C++ features: 

• Extensive example codes in VBA, C and C++, explaining all the ways in which a developer can achieve their objectives.

• Example projects that demonstrate, from start to finish, the potential of Excel when powerful add-ins can be easily developed.

• Develops the readers understanding of the relative strengths and weaknesses of developing add-ins for Excel in VBA versus C/C++.

• A CD-ROM with several thousand lines of example code, numerous workbooks, and a number of complete example projects.

Smart Client Deployment with ClickOnce or Microsoft Office Excel 2003

Smart Client Deployment with ClickOnce: Deploying Windows Forms Applications with ClickOnce

Author: Brian Noyes

Microsoft's new ClickOnce auto-updating technology can radically simplify application deployment. Using it, .NET developers and architects can deliver a powerful, smart client experience along with the easy maintenance of today's best Web applications.

Microsoft Regional Director and MVP Brian Noyes has unsurpassed experience previewing and teaching ClickOnce to professional developers. In Smart Client Deployment with ClickOnce, Noyes demonstrates exactly how to make the most of ClickOnce in your real-world enterprise applications. Noyes covers ClickOnce design, architecture, security, installation, updates, and Bootstrapping—each with a full case study and detailed sample code.

This focused, concise book explains how to

• Design client applications for efficient deployment and auto-updating
• Perform application deployments and automatic updates quickly and easily
• Deliver "on-demand" client application updates
• Deploy prerequisites with the Visual Studio 2005 Bootstrapper
• Take full control of ClickOnce's powerful publishing, update, and security options
• Leverage the Visual Studio 2005 and .NET 2.0 platform features that make ClickOnce possible
• Understand how your application will behave in the ClickOnce runtime environment
  
  
  

  See also: International Wine Guide or Guide to Craft Brewing

  Microsoft Office Excel 2003: Complete Concepts and Techniques, CourseCard E

  Author: Gary B Shelly

  For the past three decades, the Shelly Cashman Series® has effectively introduced computers to millions of students, consistently providing the highest quality, most up-to-date, and innovative materials in computer education. Enjoy the proven step-by-step style and improved Excel 2003 updates of the Shelly Cashman Series® and enhance your Office application skills today!
  

  
  
  

  Table of Contents:

  1. Creating a Worksheet and an Embedded Chart 2. Formulas, Functions, Formatting, and Web Queries 3. What-If Analysis, Charting, and Working with Large Worksheets Web Feature: Creating Static and Dynamic Web Pages Using Excel 4. Financial Functions, Data Tables, Amortization Schedules, and Hyperlinks 5. Creating, Sorting, and Querying a List 6. Creating Templates and Working with Multiple Worksheets and Workbooks Integration Feature: Object Linking and Embedding (OLE) and Web Discussions Appendices A: Microsoft Excel Help System B: Speech and Handwriting Recognition and Speech Playback C: Publishing Office Web Pages to a Web Server D: Changing Screen Resolution and Resetting the Excel Toolbars and Menus E: Microsoft Office Specialist Certification