What's New in Flash 8
Most of the improvements you see in Flash 8 compared to the previous version (Flash MX 2004) have to do with performancealways a good thing. But in addition, Macromedia also added a few usability tweaks, as well as a couple of new image-editing features.Here's a short list of the differences in Flash 8 compared to Flash MX 2004:Improved performance. Improvements include better text anti-aliasing (smoother-looking text) and the ability to cache movie clips as bitmaps at runtime (and so cut down on playback time for super-complex vector graphics, which you learn about in Chapter 2). The big news: Macromedia added a new, faster, more efficient video codec, or video compression algorithm to Flash Player 8, which comes with both Flash Basic 8 and Flash Professional 8 as well as most Web browsers and operating systems (see the box on Section 3.1). A more efficient codec means improved download and playback of any video clips you add to your animations.Improved interface. In Flash 8, you can drag a text block's resize handle and drag to expand it, which is simpler than having to resize the text block using the Property Inspector the way you had to in Flash MX 2004. A new drop-down list in the Flash 8 Library panel shows all other open libraries, making it easier to exchange imported media files and symbols between Flash documents. And scripting help is back in the form of the Scripting Assist mode. If you're running a Mac, you'll appreciate that the Mac version of Flash 8 lets you see all your open Flash documents in a single tabbed window, similar to the way you work with multiple documents in Flash when you're running Windows.New image editing features. Flash 8 introduces object drawing mode (Chapter 2), which lets you tell Flash whether you want it to treat shapes and their outlines as a unit (the way most people think of them) or separately. Flash 8 also lets you add sharp, mitered corners to rectangular objects. And Flash Professional 8 includes additional graphics effects (see the previous page).Improved support for video editing (Flash Professional 8 only). Both the Video Exporter and Video Encoder (see Section 3.2) let you compress video clips using the new and improved codecOn2 Technologies' VP6in addition to the Sorenson Spark codec supported in Flash MX 2004. New video alpha channel support lets you layer video clips using various alpha (transparency) settings.Read Comments To Download This Book
Thursday, October 2, 2008
Macromedia Fireworks 8 - Training From The Source (2005)
What You Will Learn
As you work through these lessons, you will develop the skills needed to create your own web pages.By the end of the course, you will be able to:Use the bitmap tools in Fireworks to edit an imageUse the vector tools to draw shapesCombine simple shapes to create complex objectsAdd text effects, such as text on a path, to your pagesCreate buttons with rollovers and use effects for realistic-looking buttonsOptimize and export your imagesCreate animated GIF imagesUse masking techniques for isolating portions of an imageAdd pop-up menusUse Dreamweaver to add text to your exported HTML pages
< Download Now >
As you work through these lessons, you will develop the skills needed to create your own web pages.By the end of the course, you will be able to:Use the bitmap tools in Fireworks to edit an imageUse the vector tools to draw shapesCombine simple shapes to create complex objectsAdd text effects, such as text on a path, to your pagesCreate buttons with rollovers and use effects for realistic-looking buttonsOptimize and export your imagesCreate animated GIF imagesUse masking techniques for isolating portions of an imageAdd pop-up menusUse Dreamweaver to add text to your exported HTML pages
< Download Now >
Java For Artists - The Art, Philosophy, And Science Of Object-Oriented Programming (2006)
Organization of This Book
Java For Artists is organized into six parts containing 25 chapters. Each part and the contents of its accompanying chapters is discussed below.Part I: The Java Student Survival GuideThe four chapters in part I provide important background information meant to help the reader approach the material presented in the later sections of the book. Some of the material discussed in part I, especially in chapter 3, may be too advanced to be fully understood by the novice upon first reading.Chapter 1: AN Approach To The Art Of ProgrammingChapter 1 presents a general discussion of the practical aspects of Java programming. It starts by highlighting the difficulties students will encounter when first learning Java and discusses the emotions they will feel when they begin to experience the overwhelming complexity involved with learning the syntax of the Java language, the Java API, a suitable development environment, and how to solve a problem with a computer. The chapter also presents and discusses the three software development roles students play and the activities required by each role. It goes on to discuss a general approach to the art of programming which includes a treatment on the concept of the flow, which is a transcendental state programmers and artists attain when completely absorbed in their work. The chapter concludes with a discussion of how to manage Java project physical and conceptual complexity.Chapter 2: Small VictoriesChapter 2 shows the reader how to create, compile, and run a simple Java project in several different development environments on Microsoft Windows, Apple’s OS X, and Linux operating systems. It shows the reader how to download, install, and configure the Java platform for Microsoft Windows and Linux including a discussion on how to set the PATH and CLASSPATH environment variables. The chapter concludes with a discussion on how to create executable jar files.Chapter 3: Project Walkthrough A Complete ExampleChapter 3 presents the execution of a complete Java programming project from specification to final testing. The project approach strategy and development cycle originally presented in chapter 1 are applied in a practical setting. Each iteration of the project demonstrates the use of the development cycle to include planning, coding, testing, and integration. The chapter’s overarching theme is the answer to this question: “How do you, as a beginner, maintain a sense of forward momentum on a programming project when you don’t yet have a complete grasp of the Java language, API, or your development environment?”Chapter 4: Computers, Programs, And AlgorithmsChapter 4 provides background information on how computers and programs work. It discusses the basics of computer hardware organization down to the processor level and the fundamentals of computer memory organization. It discusses the concept of a program and defines the steps of the processing cycle. The chapter concludes with a detailed discussion of the Java virtual machine (JVM) and its architecture.Part II: Language FundamentalsPart II contains chapters 5 through 11 and presents the core Java language features to include an overview of the Java API, language syntax, operators, control-flow statements, arrays, classes, compositional design and design by inheritance.Chapter 5: Overview Of The Java APIChapter 5 presents an overview of the Java platform application programming interface (API). The chapter shows readers how to consult the Java online documentation to find out information about a Java API class they want to use and how to navigate a class inheritance hierarchy to discover the class’s full functionality.Chapter 6: Simple Java Programs—Using Primitive And Reference Data TypesChapter 6 shows the reader how to write simple Java programs using primitive and reference data types. It starts by providing a definition of a Java program and discusses the difference between an application object vs. an applet object. The chapter then goes on to demonstrate how to create and compile a simple Java application. Next, the chapter discusses the concept of identifiers and identifier naming rules. It presents and discusses the Java reserved keywords, type categories, and language operators. It illustrates how to work with primitive and reference types, defines the terms variable, constant, statement, and expression, and demonstrates the accessibility between class and instance fields and the main() method. In summary, this chapter provides the fundamental footing all readers must have before attempting the remaining chapters in the book.Chapter 7: Controlling The Flow Of Program ExecutionChapter 7 presents a complete treatment of Java’s control flow statements to include the if, if/else, switch, while, do/while, and for. The chapter shows how to achieve complex program flow control by combining various controlflow statements via chaining and nesting. The chapter also presents the purpose and use of the break and continue statements.Chapter 8: ArraysChapter 8 offers a detailed discussion on the topic of Java arrays. The chapter begins by highlighting the special properties of Java array-type objects. The discussion then focuses on the functionality provided by single-dimensional arrays, followed, naturally, by multi-dimensional arrays. The material is reinforced with many illustrations showing readers how Java arrays are organized in memory. Tons of programming examples serve to reinforce the reader’s understanding of array concepts.Chapter 9: Toward Problem Abstraction Creating New Data TypesChapter 9 introduces the reader formally to the Java class construct. It starts with a discussion of problem abstraction and where the process of problem abstraction fits into the development cycle. The concept of the Unified Modeling Language (UML) class diagram is presented and is used from this point forward to communicate program designs. The Java class construct is thoroughly treated including class members, access modifiers, and static and nonstatic fields and methods. The class method is treated in detail as well and includes a discussion of method modifiers, return types, method names, parameter lists, and the method body. Numerous programming examples reinforce chapter material. The chapter concludes with a discussion of static initializers.Chapter 10: Compositional DesignChapter 10 shows readers how to create new class types from existing class types using compositional design. The chapter discusses the concepts of dependency vs. association and simple aggregation vs. composite aggregation. The chapter expands the reader’s knowledge of UML by showing how to express various types of aggregation via a UML class diagram. The chapter also introduces readers to the UML sequence diagram in conjunction with the chapter’s primary programming example. Other topics discussed in the chapter include the typesafe enumeration pattern and how to compile multiple Java source files with the javac command-line tool.Chapter 11: Extending Class Behavior Through InheritanceChapter 11 shows readers how to create new Java classes using inheritance. The chapter starts by showing how to express inheritance relationships via a UML class diagram. It then moves on to discuss the three essential purposes of inheritance, the concepts of base and derived classes, and how to override base class methods in derived classes. Next, the chapter presents a discussion of abstract base classes, abstract methods, and interfaces. It highlights the differences between abstract base classes vs. interfaces and shows readers how to represent interfaces in a UML class diagram. The chapter also presents a discussion of how to control horizontal and vertical access, and how to achieve polymorphic behavior. The primary chapter programming example shows readers how to combine compositional design with inheritance to achieve powerful results.Part III: Graphical User Interface ProgrammingPart III includes chapters 12 through 14 and gives readers a detailed treatment of graphical user interface (GUI) programming using AWT and Swing components.Chapter 12: Java Swing API OverviewChapter 12 presents the fundamental concepts of GUI programming including an overview of the fundamental components found in the Java Swing API. This chapter introduces readers to the screen coordinate system and explains the different types of windows. It discusses the differences between containers and components and explains the use and behavior of layout managers.Chapter 13: Handling GUI EventsChapter 13 moves beyond chapter 12 and shows readers how to create rich, interactive GUIs utilizing Java event handing techniques. It dives deeply into the different types of EventListener interfaces and describes the steps required to register an EventListener with a GUI object. This chapter also explains how to have events generated by GUI objects located in one class handled by an EventListener located in another class. This chapter also presents a detailed discussion of how to handle GUI events using inner and anonymous classes.Chapter 14: An Advanced GUI ProjectChapter 14 builds on chapters 12 and 13 by walking readers through the creation of a significant Java GUI project. It shows readers how Swing paints components, how to use the Graphics class, how to load resources from a package-relative path, how to write custom renderers, and how to write a custom editor. This chapter also details how to create custom Events and EventListeners, how to create an offscreen image, how to paint with transparency, and how to extend Swing components to provide significant new functionality.Part IV: Intermediate ConceptsPart IV contains four chapters that deal with exceptions, threads, collections, and file input and output. This material is considered intermediate because it is assumed at this point that readers are familiar with the core Java language features presented in part II. The material in this section should be well-understood by readers before they attempt part V—Network Programming.Chapter 15: ExceptionsChapter 15 dives deeply into the subject of exceptions. It begins by discussing the Throwable class hierarchy and explains the difference between errors, exceptions, runtime exceptions, and checked vs. unchecked exceptions. It then moves into a detailed discussion of exception handling using different combinations of the try-catch-finally blocks. The chapter then shows readers how to throw exceptions, create custom exceptions, and how to translate lowlevel exceptions into higher-level exception abstractions more appropriate for their program needs.Chapter 16: ThreadsChapter 16 focuses on the subject of thread programming. It starts with the definition of a thread and describes the different ways to start and stop a thread. It then describes the difference between extending the Thread class and implementing the Runnable interface. This chapter also explains how to set thread priorities. It correlates the behavior of thread priority to popular operating systems and explains how thread race conditions can occur. It also clearly explains the mechanics of thread synchronization and shows readers how to manage multiple threads that share common resources. The chapter concludes by showing readers how to use the Java thread wait and notify mechanism to ensure cooperation between threads.Chapter 17: CollectionsChapter 17 gives readers a solid overview of the Java collection framework. The chapter begins by explaining the rationale for a collections framework by developing a home-grown dynamic array class. It then presents an overview of the Java collections framework followed by a discussion of Java 1.4 collections. The chapter concludes with a discussion of Java 5 generics and shows readers how to use generic collection classes as well as how to write their own generic methods.Chapter 18: File I/OChapter 18 offers a fairly complete treatment of file I/O programming using the classes from the java.io package. The chapter shows readers how to make sense out of what is considered to be the most confusing package in the Java platform API. It then goes on to demonstrate the use of every class in the java.io package that can be used for file I/O. Although the focus of the chapter is on file I/O, the information learned here can be directly applied when programming network I/O operations. The chapter concludes with a comprehensive programming example showing how the RandomAccessFile class can be used to create a legacy datafile adapter.Part V: Network ProgrammingPart V consists of three chapters that cover a broad range of network programming concepts to include an introduction to networking and distributed applications, client-server applications, Remote Method Invocation (RMI) programming, Applets and JDBC.Chapter 19: Introduction To Networking And Distributed ApplicationsChapter 19 provides a broad introduction to the concepts associated with network programming and distributed applications. It begins by exploring the meaning of the term computer network and shows how the TCP/IP network protocols serve as the foundation protocols for internet programming. The chapter continues with a discussion of client-server computing, application distribution, multi-tiered applications, and physical vs. logical application tier distribution. It explains clearly how multiple JVMs must be deployed in order to execute physically-distributed Java applications. The chapter then goes on to explain the purpose and importance of the internet protocols TCP/IP. The chapter concludes with an RMI programming example on both the Java 1.4 and Java 5 platforms.Chapter 20: Client-Server ApplicationsChapter 20 focuses on client-server application programming and steps the reader through a comprehensive network programming example that utilizes both RMI and I/O streams. It explains and demonstrates the use of the ServerSocket, Socket, and Thread classes to write multi-threaded client-server applications. The chapter also explains how to use the DataInputStream and DataOutputStream classes to send data between socket-based client-server applications. Additional topics discussed in the chapter include the use of the Properties class to store and retrieve application properties, how to formulate proprietary network application protocols, how to use the Class.forName() method to dynamically load classes at application runtime, and how to use the singleton and factory design patterns in a program.Chapter 21: Applets And JDBCChapter 21 provides a discussion of applets and Java Database Connectivity (JDBC) programming. It begins with a treatment of applets, their purpose and use, and their lifecycle stages. It discusses applet security restrictions and shows readers how to design with these security restrictions in mind. The applet discussion continues by showing readers how to pass information into an applet from an HTML page via applet parameters. The chapter then presents a discussion of JDBC and shows readers how to store data to and retrieve data from a relational database via the JDBC API. The chapter concludes with a comprehensive programming example showing readers how to write an applet that serves as a front-end to an RMI-based application that uses JDBC to manipulate data stored in a MySQL database.Part VI: Object-Oriented ProgrammingPart VI contains four chapters and presents material related to the theoretical aspects of object-oriented design and programming. Topics include a deeper treatment of inheritance, composition, interfaces, polymorphic behavior, how to create well-behaved Java objects, three design principles, and a formal introduction to a few helpful design patterns.Chapter 22: Inheritance, Composition, Interfaces, And PolymorphismChapter 22 dives deeper into the topics of inheritance, compositional design, the role of interfaces, and how to achieve polymorphic behavior. It begins by comparing the goals of inheritance vs. composition and suggests that the true goal of good design is to know when the design is good enough by recognizing and making rational software engineering tradeoffs. The chapter continues by giving expanded coverage of inheritance concepts and introduces readers to Meyer’s inheritance taxonomy and Coad’s inheritance criteria. Next, the chapter explores the role of interfaces and how they can be used to reduce or eliminate intermodule dependencies. It introduces the concept of modeling dominant, collateral, and dynamic roles and suggests when interfaces might be used vs. a class hierarchy. The chapter concludes with a discussion of applied polymorphic behavior and composition-based design as a force multiplier.Chapter 23: Well-Behaved ObjectsChapter 23 shows readers how to create well-behaved Java objects by correctly overriding the methods provided by the java.lang.Object class. These methods include the toString(), equals(), hashCode(), and clone() methods. The chapter shows readers how to implement two different hash code algorithms and discusses the difference between a deep vs. a shallow copy. The chapter continues by showing readers how to implement both the java.lang.Comparable and the java.util.Comparator interfaces. It then concludes by demonstrating the use of well-behaved objects in a collection.Chapter 24: Three Design PrinciplesChapter 24 introduces readers to three important object-oriented design principles that can be immediately applied to improve the quality of their application architectures. The chapter begins with a discussion of the preferred characteristics of an object-oriented architecture. It then presents a discussion of the Liskov substitution principle and Bertrand Meyer’s design-by-contract, preconditions, postconditions, and class invariants. This is followed with a discussion of the open-closed principle and the dependency inversion principle.Chapter 25: Helpful Design PatternsChapter 25 presents a formal introduction to the topic of software design patterns. It begins by describing the purpose and use of design patterns and their origin. The chapter then discusses and demonstrates the singleton, factory, model-view-controller, and command patterns. The comprehensive programming example presented at the end of the chapter demonstrates the use of all these patterns in one application.
< Download Now >
Java For Artists is organized into six parts containing 25 chapters. Each part and the contents of its accompanying chapters is discussed below.Part I: The Java Student Survival GuideThe four chapters in part I provide important background information meant to help the reader approach the material presented in the later sections of the book. Some of the material discussed in part I, especially in chapter 3, may be too advanced to be fully understood by the novice upon first reading.Chapter 1: AN Approach To The Art Of ProgrammingChapter 1 presents a general discussion of the practical aspects of Java programming. It starts by highlighting the difficulties students will encounter when first learning Java and discusses the emotions they will feel when they begin to experience the overwhelming complexity involved with learning the syntax of the Java language, the Java API, a suitable development environment, and how to solve a problem with a computer. The chapter also presents and discusses the three software development roles students play and the activities required by each role. It goes on to discuss a general approach to the art of programming which includes a treatment on the concept of the flow, which is a transcendental state programmers and artists attain when completely absorbed in their work. The chapter concludes with a discussion of how to manage Java project physical and conceptual complexity.Chapter 2: Small VictoriesChapter 2 shows the reader how to create, compile, and run a simple Java project in several different development environments on Microsoft Windows, Apple’s OS X, and Linux operating systems. It shows the reader how to download, install, and configure the Java platform for Microsoft Windows and Linux including a discussion on how to set the PATH and CLASSPATH environment variables. The chapter concludes with a discussion on how to create executable jar files.Chapter 3: Project Walkthrough A Complete ExampleChapter 3 presents the execution of a complete Java programming project from specification to final testing. The project approach strategy and development cycle originally presented in chapter 1 are applied in a practical setting. Each iteration of the project demonstrates the use of the development cycle to include planning, coding, testing, and integration. The chapter’s overarching theme is the answer to this question: “How do you, as a beginner, maintain a sense of forward momentum on a programming project when you don’t yet have a complete grasp of the Java language, API, or your development environment?”Chapter 4: Computers, Programs, And AlgorithmsChapter 4 provides background information on how computers and programs work. It discusses the basics of computer hardware organization down to the processor level and the fundamentals of computer memory organization. It discusses the concept of a program and defines the steps of the processing cycle. The chapter concludes with a detailed discussion of the Java virtual machine (JVM) and its architecture.Part II: Language FundamentalsPart II contains chapters 5 through 11 and presents the core Java language features to include an overview of the Java API, language syntax, operators, control-flow statements, arrays, classes, compositional design and design by inheritance.Chapter 5: Overview Of The Java APIChapter 5 presents an overview of the Java platform application programming interface (API). The chapter shows readers how to consult the Java online documentation to find out information about a Java API class they want to use and how to navigate a class inheritance hierarchy to discover the class’s full functionality.Chapter 6: Simple Java Programs—Using Primitive And Reference Data TypesChapter 6 shows the reader how to write simple Java programs using primitive and reference data types. It starts by providing a definition of a Java program and discusses the difference between an application object vs. an applet object. The chapter then goes on to demonstrate how to create and compile a simple Java application. Next, the chapter discusses the concept of identifiers and identifier naming rules. It presents and discusses the Java reserved keywords, type categories, and language operators. It illustrates how to work with primitive and reference types, defines the terms variable, constant, statement, and expression, and demonstrates the accessibility between class and instance fields and the main() method. In summary, this chapter provides the fundamental footing all readers must have before attempting the remaining chapters in the book.Chapter 7: Controlling The Flow Of Program ExecutionChapter 7 presents a complete treatment of Java’s control flow statements to include the if, if/else, switch, while, do/while, and for. The chapter shows how to achieve complex program flow control by combining various controlflow statements via chaining and nesting. The chapter also presents the purpose and use of the break and continue statements.Chapter 8: ArraysChapter 8 offers a detailed discussion on the topic of Java arrays. The chapter begins by highlighting the special properties of Java array-type objects. The discussion then focuses on the functionality provided by single-dimensional arrays, followed, naturally, by multi-dimensional arrays. The material is reinforced with many illustrations showing readers how Java arrays are organized in memory. Tons of programming examples serve to reinforce the reader’s understanding of array concepts.Chapter 9: Toward Problem Abstraction Creating New Data TypesChapter 9 introduces the reader formally to the Java class construct. It starts with a discussion of problem abstraction and where the process of problem abstraction fits into the development cycle. The concept of the Unified Modeling Language (UML) class diagram is presented and is used from this point forward to communicate program designs. The Java class construct is thoroughly treated including class members, access modifiers, and static and nonstatic fields and methods. The class method is treated in detail as well and includes a discussion of method modifiers, return types, method names, parameter lists, and the method body. Numerous programming examples reinforce chapter material. The chapter concludes with a discussion of static initializers.Chapter 10: Compositional DesignChapter 10 shows readers how to create new class types from existing class types using compositional design. The chapter discusses the concepts of dependency vs. association and simple aggregation vs. composite aggregation. The chapter expands the reader’s knowledge of UML by showing how to express various types of aggregation via a UML class diagram. The chapter also introduces readers to the UML sequence diagram in conjunction with the chapter’s primary programming example. Other topics discussed in the chapter include the typesafe enumeration pattern and how to compile multiple Java source files with the javac command-line tool.Chapter 11: Extending Class Behavior Through InheritanceChapter 11 shows readers how to create new Java classes using inheritance. The chapter starts by showing how to express inheritance relationships via a UML class diagram. It then moves on to discuss the three essential purposes of inheritance, the concepts of base and derived classes, and how to override base class methods in derived classes. Next, the chapter presents a discussion of abstract base classes, abstract methods, and interfaces. It highlights the differences between abstract base classes vs. interfaces and shows readers how to represent interfaces in a UML class diagram. The chapter also presents a discussion of how to control horizontal and vertical access, and how to achieve polymorphic behavior. The primary chapter programming example shows readers how to combine compositional design with inheritance to achieve powerful results.Part III: Graphical User Interface ProgrammingPart III includes chapters 12 through 14 and gives readers a detailed treatment of graphical user interface (GUI) programming using AWT and Swing components.Chapter 12: Java Swing API OverviewChapter 12 presents the fundamental concepts of GUI programming including an overview of the fundamental components found in the Java Swing API. This chapter introduces readers to the screen coordinate system and explains the different types of windows. It discusses the differences between containers and components and explains the use and behavior of layout managers.Chapter 13: Handling GUI EventsChapter 13 moves beyond chapter 12 and shows readers how to create rich, interactive GUIs utilizing Java event handing techniques. It dives deeply into the different types of EventListener interfaces and describes the steps required to register an EventListener with a GUI object. This chapter also explains how to have events generated by GUI objects located in one class handled by an EventListener located in another class. This chapter also presents a detailed discussion of how to handle GUI events using inner and anonymous classes.Chapter 14: An Advanced GUI ProjectChapter 14 builds on chapters 12 and 13 by walking readers through the creation of a significant Java GUI project. It shows readers how Swing paints components, how to use the Graphics class, how to load resources from a package-relative path, how to write custom renderers, and how to write a custom editor. This chapter also details how to create custom Events and EventListeners, how to create an offscreen image, how to paint with transparency, and how to extend Swing components to provide significant new functionality.Part IV: Intermediate ConceptsPart IV contains four chapters that deal with exceptions, threads, collections, and file input and output. This material is considered intermediate because it is assumed at this point that readers are familiar with the core Java language features presented in part II. The material in this section should be well-understood by readers before they attempt part V—Network Programming.Chapter 15: ExceptionsChapter 15 dives deeply into the subject of exceptions. It begins by discussing the Throwable class hierarchy and explains the difference between errors, exceptions, runtime exceptions, and checked vs. unchecked exceptions. It then moves into a detailed discussion of exception handling using different combinations of the try-catch-finally blocks. The chapter then shows readers how to throw exceptions, create custom exceptions, and how to translate lowlevel exceptions into higher-level exception abstractions more appropriate for their program needs.Chapter 16: ThreadsChapter 16 focuses on the subject of thread programming. It starts with the definition of a thread and describes the different ways to start and stop a thread. It then describes the difference between extending the Thread class and implementing the Runnable interface. This chapter also explains how to set thread priorities. It correlates the behavior of thread priority to popular operating systems and explains how thread race conditions can occur. It also clearly explains the mechanics of thread synchronization and shows readers how to manage multiple threads that share common resources. The chapter concludes by showing readers how to use the Java thread wait and notify mechanism to ensure cooperation between threads.Chapter 17: CollectionsChapter 17 gives readers a solid overview of the Java collection framework. The chapter begins by explaining the rationale for a collections framework by developing a home-grown dynamic array class. It then presents an overview of the Java collections framework followed by a discussion of Java 1.4 collections. The chapter concludes with a discussion of Java 5 generics and shows readers how to use generic collection classes as well as how to write their own generic methods.Chapter 18: File I/OChapter 18 offers a fairly complete treatment of file I/O programming using the classes from the java.io package. The chapter shows readers how to make sense out of what is considered to be the most confusing package in the Java platform API. It then goes on to demonstrate the use of every class in the java.io package that can be used for file I/O. Although the focus of the chapter is on file I/O, the information learned here can be directly applied when programming network I/O operations. The chapter concludes with a comprehensive programming example showing how the RandomAccessFile class can be used to create a legacy datafile adapter.Part V: Network ProgrammingPart V consists of three chapters that cover a broad range of network programming concepts to include an introduction to networking and distributed applications, client-server applications, Remote Method Invocation (RMI) programming, Applets and JDBC.Chapter 19: Introduction To Networking And Distributed ApplicationsChapter 19 provides a broad introduction to the concepts associated with network programming and distributed applications. It begins by exploring the meaning of the term computer network and shows how the TCP/IP network protocols serve as the foundation protocols for internet programming. The chapter continues with a discussion of client-server computing, application distribution, multi-tiered applications, and physical vs. logical application tier distribution. It explains clearly how multiple JVMs must be deployed in order to execute physically-distributed Java applications. The chapter then goes on to explain the purpose and importance of the internet protocols TCP/IP. The chapter concludes with an RMI programming example on both the Java 1.4 and Java 5 platforms.Chapter 20: Client-Server ApplicationsChapter 20 focuses on client-server application programming and steps the reader through a comprehensive network programming example that utilizes both RMI and I/O streams. It explains and demonstrates the use of the ServerSocket, Socket, and Thread classes to write multi-threaded client-server applications. The chapter also explains how to use the DataInputStream and DataOutputStream classes to send data between socket-based client-server applications. Additional topics discussed in the chapter include the use of the Properties class to store and retrieve application properties, how to formulate proprietary network application protocols, how to use the Class.forName() method to dynamically load classes at application runtime, and how to use the singleton and factory design patterns in a program.Chapter 21: Applets And JDBCChapter 21 provides a discussion of applets and Java Database Connectivity (JDBC) programming. It begins with a treatment of applets, their purpose and use, and their lifecycle stages. It discusses applet security restrictions and shows readers how to design with these security restrictions in mind. The applet discussion continues by showing readers how to pass information into an applet from an HTML page via applet parameters. The chapter then presents a discussion of JDBC and shows readers how to store data to and retrieve data from a relational database via the JDBC API. The chapter concludes with a comprehensive programming example showing readers how to write an applet that serves as a front-end to an RMI-based application that uses JDBC to manipulate data stored in a MySQL database.Part VI: Object-Oriented ProgrammingPart VI contains four chapters and presents material related to the theoretical aspects of object-oriented design and programming. Topics include a deeper treatment of inheritance, composition, interfaces, polymorphic behavior, how to create well-behaved Java objects, three design principles, and a formal introduction to a few helpful design patterns.Chapter 22: Inheritance, Composition, Interfaces, And PolymorphismChapter 22 dives deeper into the topics of inheritance, compositional design, the role of interfaces, and how to achieve polymorphic behavior. It begins by comparing the goals of inheritance vs. composition and suggests that the true goal of good design is to know when the design is good enough by recognizing and making rational software engineering tradeoffs. The chapter continues by giving expanded coverage of inheritance concepts and introduces readers to Meyer’s inheritance taxonomy and Coad’s inheritance criteria. Next, the chapter explores the role of interfaces and how they can be used to reduce or eliminate intermodule dependencies. It introduces the concept of modeling dominant, collateral, and dynamic roles and suggests when interfaces might be used vs. a class hierarchy. The chapter concludes with a discussion of applied polymorphic behavior and composition-based design as a force multiplier.Chapter 23: Well-Behaved ObjectsChapter 23 shows readers how to create well-behaved Java objects by correctly overriding the methods provided by the java.lang.Object class. These methods include the toString(), equals(), hashCode(), and clone() methods. The chapter shows readers how to implement two different hash code algorithms and discusses the difference between a deep vs. a shallow copy. The chapter continues by showing readers how to implement both the java.lang.Comparable and the java.util.Comparator interfaces. It then concludes by demonstrating the use of well-behaved objects in a collection.Chapter 24: Three Design PrinciplesChapter 24 introduces readers to three important object-oriented design principles that can be immediately applied to improve the quality of their application architectures. The chapter begins with a discussion of the preferred characteristics of an object-oriented architecture. It then presents a discussion of the Liskov substitution principle and Bertrand Meyer’s design-by-contract, preconditions, postconditions, and class invariants. This is followed with a discussion of the open-closed principle and the dependency inversion principle.Chapter 25: Helpful Design PatternsChapter 25 presents a formal introduction to the topic of software design patterns. It begins by describing the purpose and use of design patterns and their origin. The chapter then discusses and demonstrates the singleton, factory, model-view-controller, and command patterns. The comprehensive programming example presented at the end of the chapter demonstrates the use of all these patterns in one application.
< Download Now >
IPv6 Essentials, 2nd Edition (2006)
This book is about the next generation Internet protocol. We have become familiar with the strengths and weaknesses of IPv4; we know how to design and configure it, and we have learned how to troubleshoot it. And now we have to learn a new protocol? Start from scratch? Not really. The designers of IPv6 have learned a lot from over 15 years of experience with IPv4, and they have been working on the new protocol since the early 1990s. They retained the strengths of IPv4, extended the address space from 32 bits to 128 bits, and added functionality that is missing in IPv4. They developed transition mechanisms that make IPv4 and IPv6 coexist peacefully and that guarantee a smooth transition between the protocols. In fact, this was one of the major requirements for the development of the new protocol version.So you do not need to forget what you know about IPv4; many things will feel familiar with IPv6. When you get started, you will discover new features and functionalities that will make your life a lot easier. IPv6 has features that you will need in tomorrow's networksfeatures that IPv4 does not provide. The day will come when our Personal Digital Assistants (PDAs) and mobile phones have IP addresses. Aside from the fact that the IPv4 address space could never cover the demand for that number of IP addresses, imagine configuring those devices with the means we have today!One of the coolest features built into IPv6 is the autoconfiguration capability. Haven't we always struggled with IP address assignment? The advent of DHCP made our lives a little easier, but now we need to maintain and troubleshoot the DHCP servers. And when our refrigerator, our PDA, and our TV each have an IP address, will we need a DHCP server at home? Not with autoconfiguration. If you have an IPv6-enabled host, you can plug it into your network, and it will configure automatically for a valid IPv6 address. Internet Control Message Protocol (ICMP), which is a networker's best friend, has become much more powerful with IPv6. Many of the new features of IPv6, such as autoconfiguration, optimized multicast routing and multicast group management, Neighbor Discovery, path MTU discovery, and Mobile IPv6 are based on ICMPv6.I hope that this book will help you to become familiar with the protocol and provide an easy-to-understand entry point and guide to exploring this new area.
< Download Now >
< Download Now >
IPSec VPN Design (2005)
Master IPSec-based Virtual Private Networks with guidance from the Cisco Systems® VPN Solutions group
Understand how IPSec VPNs are designed, built, and administeredImprove VPN performance through enabling of modern VPN services such as performance, scalability, QoS, packet processing, multicast, and securityIntegrate IPSec VPNs with MPLS, Frame Relay, and ATM technologiesAs the number of remote branches and work-from-home employees grows throughout corporate America, VPNs are becoming essential to both enterprise networks and service providers. IPSec is one of the more popular technologies for deploying IP-based VPNs. IPSec VPN Design provides a solid understanding of the design and architectural issues of IPSec VPNs. Some books cover IPSec protocols, but they do not address overall design issues. This book fills that void.IPSec VPN Design consists of three main sections. The first section provides a comprehensive introduction to the IPSec protocol, including IPSec Peer Models. This section also includes an introduction to site-to-site, network-based, and remote access VPNs. The second section is dedicated to an analysis of IPSec VPN architecture and proper design methodologies. Peer relationships and fault tolerance models and architectures are examined in detail. Part three addresses enabling VPN services, such as performance, scalability, packet processing, QoS, multicast, and security. This book also covers the integration of IPSec VPNs with other Layer 3 (MPLS VPN) and Layer 2 (Frame Relay, ATM) technologies; and discusses management, provisioning, and troubleshooting techniques. Case studies highlight design, implementation, and management advice to be applied in both service provider and enterprise environments.
< Download Now >
Understand how IPSec VPNs are designed, built, and administeredImprove VPN performance through enabling of modern VPN services such as performance, scalability, QoS, packet processing, multicast, and securityIntegrate IPSec VPNs with MPLS, Frame Relay, and ATM technologiesAs the number of remote branches and work-from-home employees grows throughout corporate America, VPNs are becoming essential to both enterprise networks and service providers. IPSec is one of the more popular technologies for deploying IP-based VPNs. IPSec VPN Design provides a solid understanding of the design and architectural issues of IPSec VPNs. Some books cover IPSec protocols, but they do not address overall design issues. This book fills that void.IPSec VPN Design consists of three main sections. The first section provides a comprehensive introduction to the IPSec protocol, including IPSec Peer Models. This section also includes an introduction to site-to-site, network-based, and remote access VPNs. The second section is dedicated to an analysis of IPSec VPN architecture and proper design methodologies. Peer relationships and fault tolerance models and architectures are examined in detail. Part three addresses enabling VPN services, such as performance, scalability, packet processing, QoS, multicast, and security. This book also covers the integration of IPSec VPNs with other Layer 3 (MPLS VPN) and Layer 2 (Frame Relay, ATM) technologies; and discusses management, provisioning, and troubleshooting techniques. Case studies highlight design, implementation, and management advice to be applied in both service provider and enterprise environments.
< Download Now >
iPod & iTunes - The Missing Manual, 4th Edition (2006)
When Apple introduced the iPod in 2001, CEO Steve Jobs declared, "listening to music will never be the same again." He was right on the money. The iPod grabbed attention right away, and by the end of 2005, more than 41 million of them had sold. iPod is the dominant digital music player on the market, and for the first time, Apple gets to feel like Microsoft.iPod steadily evolved through five gen erations since then, and today the dynasty ranges from a screenless 512-megabyte version that can hold plenty of songs for your gym routine to a 60-gigabyte multimedia jukebox that can spin out an entire season of "Desperate Housewives", along with thousands of color photos and all that colorful music.An iPod is many things to many people, but it can be much more than most people realize. That's where iPod & iTunes: The Missing Manual comes in. Like the device itself, this book is a long-running bestseller, now in its fourth edition. What makes it so popular is the wealth of useful information it brings to anyone who breaks open iPod's distinctive packaging-especially since Apple doesn't supply a manual of its own.Once again, we've updated this guide to fully explain the ins and outs of iPod, including the nano, the shuffle, and all the latest features and uses, such as:The 5th generation Video iPod, which can hold 15,000 songs, 25,000 photos, and 150 hours of videoiTunes 6, where you can buy tunes, subscribe to Podcasts, tune into internet radio, download videos, build playlists, and moreGoing beyond the music to use iPod as an external drive, an eBook, a personal organizer, a GameBoy, and a slide projectorExtreme iPodding with shareware and AppleScripts, using an iPod with external speakers (including the car stereo), accessories, and troubleshootingIt's been five years since iPod hit the scene, but, clearly, the evolution has only just begun. iPod & iTunes: The Missing Manual gives you everything you need to evolve with it.
< Download Now >
< Download Now >
iPhoto 6 For Mac OS X - Visual QuickStart Guide (2006)
Need to learn iPhoto 6 fast? Try a Visual QuickStart! This best-selling reference's visual format and step-by-step, task-based instructions will have you up and running with this great iLife 06 application in no time. Best-selling author and instructor Adam Engst uses crystal-clear instructions, full-color illustrations, and friendly prose to introduce you to everything from importing, tagging, editing, and perfecting images to creating slideshows and photo albums to easy online Web publishing. You'll also learn about everything new in iPhoto 6, including enhanced editing and special effects, calendars and cards, photocasting, and more!
< Download Now >
< Download Now >
Subscribe to:
Posts (Atom)
