Content URL: Link To Content
Create configurable worksheets (with answers, no answers, etc.), for use by teachers or students .
Create configurable worksheets (with answers, no answers, etc.), for use by teachers or students .
Free Books and Solutions Manual Headline
Showing posts with label Documents. Show all posts
Showing posts with label Documents. Show all posts
Tuesday, 24 May 2011
Course of Differential Geometry
Content URL: Link To Content
This book is a textbook for the basic course of differential geometry. It is recommended as an introductory material for this subject. This book is devoted to the first acquaintance with the differential geometry.
This book is a textbook for the basic course of differential geometry. It is recommended as an introductory material for this subject. This book is devoted to the first acquaintance with the differential geometry.
Labels:
and Lectures,
Documents,
Geometry Books
Discrete Mathematics Lecture Notes - William Chen
Content URL: Link To Content
This set of notes has been compiled over a period of more than 20 years. Chapters 1-4 were used in various forms and on many occasions between 1981 and 1990 by the author at Imperial College, University of London. An extra 14 chapters were written in Sydney in 1991 and 1992. Chapters 7 and 12 were added in 1997.
The material has been organized in such a way to create a single volume suitable for use in the unit MATH237 at Macquarie University. This unit is currently taught in two parallel strands. The following is the suggested order for the presentation of the material:
* C: Chapters 1, 2, 5, 6, 7, 8, 9, 10, 11 and 12.
* M: Chapters 3, 4, 13, 14, 15, 16, 17, 18, 19 and 20.
To read the notes, click the chapters below for connection to the appropriate PDF files. You will need Adobe Acrobat Reader Version 4.0 or later.
The material is available free to all individuals, on the understanding that it is not to be used for financial gains, and may be downloaded and/or photocopied, with or without permission from the author. However, the documents may not be kept on any information storage and retrieval system without permission from the author, unless such system is not accessible to any individuals other than its owners.
This set of notes has been compiled over a period of more than 20 years. Chapters 1-4 were used in various forms and on many occasions between 1981 and 1990 by the author at Imperial College, University of London. An extra 14 chapters were written in Sydney in 1991 and 1992. Chapters 7 and 12 were added in 1997.
The material has been organized in such a way to create a single volume suitable for use in the unit MATH237 at Macquarie University. This unit is currently taught in two parallel strands. The following is the suggested order for the presentation of the material:
* C: Chapters 1, 2, 5, 6, 7, 8, 9, 10, 11 and 12.
* M: Chapters 3, 4, 13, 14, 15, 16, 17, 18, 19 and 20.
To read the notes, click the chapters below for connection to the appropriate PDF files. You will need Adobe Acrobat Reader Version 4.0 or later.
The material is available free to all individuals, on the understanding that it is not to be used for financial gains, and may be downloaded and/or photocopied, with or without permission from the author. However, the documents may not be kept on any information storage and retrieval system without permission from the author, unless such system is not accessible to any individuals other than its owners.
Labels:
and Lectures,
Discrete Mathematics Books,
Documents
Discrete Mathematics
Content URL: Link To Content
There are many success stories of applied mathematics outside calculus. A recent hot topic is mathematical cryptography, which is based on number theory (the study of positive integers 1,2,3,...), and is widely applied, among others, in computer security and electronic banking. Other important areas in applied mathematics include linear programming, coding theory, theory of computing. The mathematics in these applications is collectively called discrete mathematics. ("Discrete" here is used as the opposite of "continuous"; it is also often used in the more restrictive sense of "finite".)
The aim of this book is not to cover "discrete mathematics" in depth (it should be clear from the description above that such a task would he ill-defined and impossible anyway). Rather, this book discusses a number of selected results and methods, mostly from the areas of combinatorics, graph theory, and combinatorial geometry, with a little elementary number theory.
At the same time, it is important to realize that mathematics cannot be done without proofs. Merely stating the facts, without, saying something about why these facts are valid, would be terribly far from the spirit of mathematics and would make it impossible to give any idea about how it works. Thus, wherever possible, this book will give the proofs of the theorems stated. Sometimes this is not possible; quite simple, elementary facts can be extremely difficult to prove, and some such proofs may take advanced courses to go through. In these cases, this book will state at least that the proof is highly technical and goes beyond the scope of this book.
Another important, ingredient of mathematics is problem solving. One won't be able to learn any mathematics without dirtying his hands and trying out the ideas he learn about in the solution of problems. To some, this may sound frightening, but in fact most people pursue this type of activity almost, every day: everybody who plays a game of chess, or solves a puzzle, is solving discrete mathematical problems. The reader is strongly advised to answer the questions posed in the text and to go through the problems at the end of each chapter of this book.
There are many success stories of applied mathematics outside calculus. A recent hot topic is mathematical cryptography, which is based on number theory (the study of positive integers 1,2,3,...), and is widely applied, among others, in computer security and electronic banking. Other important areas in applied mathematics include linear programming, coding theory, theory of computing. The mathematics in these applications is collectively called discrete mathematics. ("Discrete" here is used as the opposite of "continuous"; it is also often used in the more restrictive sense of "finite".)
The aim of this book is not to cover "discrete mathematics" in depth (it should be clear from the description above that such a task would he ill-defined and impossible anyway). Rather, this book discusses a number of selected results and methods, mostly from the areas of combinatorics, graph theory, and combinatorial geometry, with a little elementary number theory.
At the same time, it is important to realize that mathematics cannot be done without proofs. Merely stating the facts, without, saying something about why these facts are valid, would be terribly far from the spirit of mathematics and would make it impossible to give any idea about how it works. Thus, wherever possible, this book will give the proofs of the theorems stated. Sometimes this is not possible; quite simple, elementary facts can be extremely difficult to prove, and some such proofs may take advanced courses to go through. In these cases, this book will state at least that the proof is highly technical and goes beyond the scope of this book.
Another important, ingredient of mathematics is problem solving. One won't be able to learn any mathematics without dirtying his hands and trying out the ideas he learn about in the solution of problems. To some, this may sound frightening, but in fact most people pursue this type of activity almost, every day: everybody who plays a game of chess, or solves a puzzle, is solving discrete mathematical problems. The reader is strongly advised to answer the questions posed in the text and to go through the problems at the end of each chapter of this book.
Labels:
and Lectures,
Discrete Mathematics Books,
Documents
Monday, 23 May 2011
XML and XSL Tutorials (Dick Baldwin)
Content URL: Link To Content
Contents
2210 Java JAXP, Transforming XML to XHTML
2208 Java JAXP, Writing Java Code to Emulate an XSLT Transformation
Java API for XML Processing (JAXP)
2206 Java JAXP, Implementing Default XSLT Behavior in Java
2204 Java JAXP, Exposing a DOM Tree
2202 Getting Started with Java JAXP and XSL Transformations (XSLT)
2200 Java API for XML Processing (JAXP), Getting Started
Parsing XML Documents
850 Learning XML: Parsing XML Documents: Events, Part 6
840 Learning XML: Parsing XML Documents: Events, Part 5
830 Learning XML: Parsing XML Documents: Events, Part 4
820 Learning XML: Parsing XML Documents: Events, Part 3
810 Learning XML: Parsing XML Documents: Events, Part 2
800 Learning XML: Parsing XML Documents: Events, Part 1
XSL Tutorials
660 Learning XML: XSLT Sorting
650 Learning XML: Making Choices
640 Learning XML: Trees, Nodes, and Templates, Part III
630 Learning XML: Trees, Nodes, and Templates, Part II
620 Learning XML: Trees, Nodes, and Templates, Part I
610 Using Conditional Tests
600 Using XML Attribute Values
590 Inserting Attributes Into the Output Stream
580 From XML Data to HTML Tables
570 Introduction to Transformations (XSLT) using IE5 (Part 2)
560 Part I: Introduction to Transformations (XSLT) using IE5
550 XSL and XSL Transformations (XSLT), Getting Started
XML for Beginners
200 Part VI: Valid Documents, Well-Formed Documents, and the DTD
190 Part V: Content
180 Part IV: Elements
170 Part III: Tags and Attributes
160 Part II: Creating and Maintaining Structure
150 Part I: Structured Documents, Plain Text, and Rendering
Contents
2210 Java JAXP, Transforming XML to XHTML
2208 Java JAXP, Writing Java Code to Emulate an XSLT Transformation
Java API for XML Processing (JAXP)
2206 Java JAXP, Implementing Default XSLT Behavior in Java
2204 Java JAXP, Exposing a DOM Tree
2202 Getting Started with Java JAXP and XSL Transformations (XSLT)
2200 Java API for XML Processing (JAXP), Getting Started
Parsing XML Documents
850 Learning XML: Parsing XML Documents: Events, Part 6
840 Learning XML: Parsing XML Documents: Events, Part 5
830 Learning XML: Parsing XML Documents: Events, Part 4
820 Learning XML: Parsing XML Documents: Events, Part 3
810 Learning XML: Parsing XML Documents: Events, Part 2
800 Learning XML: Parsing XML Documents: Events, Part 1
XSL Tutorials
660 Learning XML: XSLT Sorting
650 Learning XML: Making Choices
640 Learning XML: Trees, Nodes, and Templates, Part III
630 Learning XML: Trees, Nodes, and Templates, Part II
620 Learning XML: Trees, Nodes, and Templates, Part I
610 Using Conditional Tests
600 Using XML Attribute Values
590 Inserting Attributes Into the Output Stream
580 From XML Data to HTML Tables
570 Introduction to Transformations (XSLT) using IE5 (Part 2)
560 Part I: Introduction to Transformations (XSLT) using IE5
550 XSL and XSL Transformations (XSLT), Getting Started
XML for Beginners
200 Part VI: Valid Documents, Well-Formed Documents, and the DTD
190 Part V: Content
180 Part IV: Elements
170 Part III: Tags and Attributes
160 Part II: Creating and Maintaining Structure
150 Part I: Structured Documents, Plain Text, and Rendering
Labels:
and Lectures,
Documents,
XML Books
Web Style Guide: Basic Design Principles for Creating Web Sites, Second Edition
Content URL: Link To Content
THIS BOOK IS FOR ALL THOSE who wish to publish durable content on the Web. Durable content is not guided by trends; good design will withstand the test of time, whereas trends quickly become frivolous. Success in Web design goes beyond technology and fashion. To create Web sites that endure you need only to communicate your ideas clearly and effectively to your readers.
Our purpose for writing this book is to offer basic design principles that you can use to make your content as easy to understand as possible. We explain how to use design as a tool, not as an objective; your Web design should be almost transparent to the reader. We show you how to create a user interface that will allow visitors to your site to navigate your content with ease. We offer suggestions on how to write Web documents; this is a new genre with its own style and guidelines. We delve deep into Web images — color, resolution, compression, and formats — and discuss the benefits of publishing images on the Web. We cover the stylistic and technical issues surrounding the addition of dynamic media to your Web site. All the guidance we offer shares a single purpose: to make your message clear to your readers.
This is not an HTML manual, nor is it a book on graphic design. It is a practical guide to help you design Web sites for the long run.
From the Second Edition's Preface:
The guidance we offer in Web Style Guide has always been grounded on the functional aspects of design. In this second edition we extend our focus on functionality with additional sections on Web site accessibility, Cascading Style Sheets, and flexible page design. We include additional sections on information architecture, site maintenance, and multimedia design. And we have added illustrations and updated our Web site examples to reflect current best practices.
THIS BOOK IS FOR ALL THOSE who wish to publish durable content on the Web. Durable content is not guided by trends; good design will withstand the test of time, whereas trends quickly become frivolous. Success in Web design goes beyond technology and fashion. To create Web sites that endure you need only to communicate your ideas clearly and effectively to your readers.
Our purpose for writing this book is to offer basic design principles that you can use to make your content as easy to understand as possible. We explain how to use design as a tool, not as an objective; your Web design should be almost transparent to the reader. We show you how to create a user interface that will allow visitors to your site to navigate your content with ease. We offer suggestions on how to write Web documents; this is a new genre with its own style and guidelines. We delve deep into Web images — color, resolution, compression, and formats — and discuss the benefits of publishing images on the Web. We cover the stylistic and technical issues surrounding the addition of dynamic media to your Web site. All the guidance we offer shares a single purpose: to make your message clear to your readers.
This is not an HTML manual, nor is it a book on graphic design. It is a practical guide to help you design Web sites for the long run.
From the Second Edition's Preface:
The guidance we offer in Web Style Guide has always been grounded on the functional aspects of design. In this second edition we extend our focus on functionality with additional sections on Web site accessibility, Cascading Style Sheets, and flexible page design. We include additional sections on information architecture, site maintenance, and multimedia design. And we have added illustrations and updated our Web site examples to reflect current best practices.
Labels:
Documents,
Web Design Books
x86 Assembly Wikibook
Link To Content
This book covers assembly language programming for the x86 family of microprocessors. The objective is to teach how to program in x86 assembly, as well as the history and basic architecture of x86 processor family,.
When referring to x86 we address the complete range of x86-based processors but keep in mind that x86-32 Assembly is commonly referred to as IA-32 (Intel Architecture, 32-bit) Assembly, a 32-bit extension of the original Intel x86 processor architecture. IA-32 has full backwards compatibility (16-bit). AMD64 or AMD 64-bit extension is called x86-64 and is backwards compatible with 32-bit code without performance loss. Intel 64 previously named IA-32e or EM64T is almost identical to x86-64. Throughout the book these terms may be used interchangeably when appropriate. A special notice will be given if covering 16-bit, 32-bit or 64-bits architectures and on any limitations so to limit confusion.
This book covers assembly language programming for the x86 family of microprocessors. The objective is to teach how to program in x86 assembly, as well as the history and basic architecture of x86 processor family,.
When referring to x86 we address the complete range of x86-based processors but keep in mind that x86-32 Assembly is commonly referred to as IA-32 (Intel Architecture, 32-bit) Assembly, a 32-bit extension of the original Intel x86 processor architecture. IA-32 has full backwards compatibility (16-bit). AMD64 or AMD 64-bit extension is called x86-64 and is backwards compatible with 32-bit code without performance loss. Intel 64 previously named IA-32e or EM64T is almost identical to x86-64. Throughout the book these terms may be used interchangeably when appropriate. A special notice will be given if covering 16-bit, 32-bit or 64-bits architectures and on any limitations so to limit confusion.
Win32 Programming for x86 Assembly Language Programmers
Link To Content
Contents:
The very beginnings
1 Introduction to Console Applications and Files
2 A Basic Win32 GUI Program--WINBASIC.ASM
3 Translating Win32 Documentation
Some fundamentals
4 Popup Windows and Ownership
5 Child Windows
6 A Little More on Messages and an Introduction to the Mouse
7 Introduction to Graphics
8 Refreshing with WM_PAINT
9 Introduction to Controls
Message loops
10 Conventional and Thread Message Loops
11 Greedy Message Loop
GUI topics
12 BUTTON
12 Introduction to Menus
12 Introduction to Dialogs
Non-GUI topics
13 Window Styles
14 Deadlock Theory
15 More Programming Information
15 The Rest of Windows
Contents:
The very beginnings
1 Introduction to Console Applications and Files
2 A Basic Win32 GUI Program--WINBASIC.ASM
3 Translating Win32 Documentation
Some fundamentals
4 Popup Windows and Ownership
5 Child Windows
6 A Little More on Messages and an Introduction to the Mouse
7 Introduction to Graphics
8 Refreshing with WM_PAINT
9 Introduction to Controls
Message loops
10 Conventional and Thread Message Loops
11 Greedy Message Loop
GUI topics
12 BUTTON
12 Introduction to Menus
12 Introduction to Dialogs
Non-GUI topics
13 Window Styles
14 Deadlock Theory
15 More Programming Information
15 The Rest of Windows
The Art of Assembly Languange
Link To Content
The Art of Assembly Language Programming is the World's #1 book on x86 assembly language programming! Thousands upon thousands of programmers have learned assembly language programming using The Art of Assembly Language. You, too, will learn this powerful programming language easier than ever before possible using The Art of Assembly Language Programming (AoA).
No single textbook can be all things to all people. This text is no exception. I've geared this text and the accompanying software to University level students who've never previously learned assembly language programming. This is not to say that others cannot benefit from this work; it simply means that as I've had to make choices about the presentation, I've made choices that should prove most comfortable for this audience I've chosen.
A secondary audience who could benefit from this presentation is any motivated person that really wants to learn assembly language. Although I assume a certain level of mathematical maturity from the reader (i.e., high school algebra), most of the "tough math" in this textbook is incidental to learning assembly language programming and you can easily skip over it without fear that you'll miss too much. High school students and those who haven't seen a school in 40 years have effectively used this text (and its DOS counterpart) to learn assembly language programming.
The organization of this text reflects the diverse audience for which it is intended. For example, in a standard textbook each chapter typically has its own set of questions, programming exercises, and laboratory exercises. Since the primary audience for this text is University students, such pedagogical material does appear within this text. However, recognizing that not everyone who reads this text wants to bother with this material (e.g., downloading it), this text moves such pedagogical material to the end of each volume in the text and places this material in a separate chapter. This is somewhat of an unusual organization, but I feel that University instructors can easily adapt to this organization and it saves burdening those who aren't interested in this material.
One audience to whom this book is specifically not directed are those persons who are already comfortable programming in 80x86 assembly language. Undoubtedly, there is a lot of material such programmers will find of use in this textbook. However, my experience suggests that those who've already learned x86 assembly language with an assembler like MASM, TASM, or NASM rebel at the thought of having to relearn basic assembly language syntax (as they would to have to learn HLA). If you fall into this category, I humbly apologize for not writing a text more to your liking. However, my goal has always been to teach those who don't already know assembly language, not extend the education of those who do. If you happen to fall into this category and you don't particularly like this text's presentation, there is some good news: there are dozens of texts on assembly language programming that use MASM and TASM out there. So you don't really need this one.
The first thing any instructor will notice when reviewing this text is that it's far too large for any reasonable course. That's because assembly language courses generally come in two flavors: a machine organization course (more hardware oriented) and an assembly language programming course (more software oriented). No text that is "just the right size" is suitable for both types of classes. Combining the information for both courses, plus advanced information students may need after they finish the course, produces a large text, like this one.
If you're an instructor with a limited schedule for teaching this subject, you'll have to carefully select the material you choose to present over the time span of your course. To help, I've included some brief notes at the beginning of each Volume in this text that suggests whether a chapter in that Volume is appropriate for a machine organization course, an assembly language programming course, or an advanced assembly programming course. These brief course notes can help you choose which chapters you want to cover in your course.
If you would like to offer hard copies of this text in the bookstore for your students, I will attempt to arrange with some "Custom Textbook Publishing" houses to make this material available on an "as-requested" basis. As I work out arrangements with such outfits, I'll post ordering information on Webster ( http://webster.cs.ucr.edu ). If your school has a printing and reprographics department, or you have a local business that handles custom publishing, you can certainly request copyright clearance to print the text locally.
If you're not taking a formal course, just keep in mind that you don't have to read this text straight through, chapter by chapter. If you want to learn assembly language programming and some of the machine organization chapters seem a little too hardware oriented for your tastes, feel free to skip those chapters and come back to them later on, when you understand the need to learn this information.
The Art of Assembly Language Programming is the World's #1 book on x86 assembly language programming! Thousands upon thousands of programmers have learned assembly language programming using The Art of Assembly Language. You, too, will learn this powerful programming language easier than ever before possible using The Art of Assembly Language Programming (AoA).
No single textbook can be all things to all people. This text is no exception. I've geared this text and the accompanying software to University level students who've never previously learned assembly language programming. This is not to say that others cannot benefit from this work; it simply means that as I've had to make choices about the presentation, I've made choices that should prove most comfortable for this audience I've chosen.
A secondary audience who could benefit from this presentation is any motivated person that really wants to learn assembly language. Although I assume a certain level of mathematical maturity from the reader (i.e., high school algebra), most of the "tough math" in this textbook is incidental to learning assembly language programming and you can easily skip over it without fear that you'll miss too much. High school students and those who haven't seen a school in 40 years have effectively used this text (and its DOS counterpart) to learn assembly language programming.
The organization of this text reflects the diverse audience for which it is intended. For example, in a standard textbook each chapter typically has its own set of questions, programming exercises, and laboratory exercises. Since the primary audience for this text is University students, such pedagogical material does appear within this text. However, recognizing that not everyone who reads this text wants to bother with this material (e.g., downloading it), this text moves such pedagogical material to the end of each volume in the text and places this material in a separate chapter. This is somewhat of an unusual organization, but I feel that University instructors can easily adapt to this organization and it saves burdening those who aren't interested in this material.
One audience to whom this book is specifically not directed are those persons who are already comfortable programming in 80x86 assembly language. Undoubtedly, there is a lot of material such programmers will find of use in this textbook. However, my experience suggests that those who've already learned x86 assembly language with an assembler like MASM, TASM, or NASM rebel at the thought of having to relearn basic assembly language syntax (as they would to have to learn HLA). If you fall into this category, I humbly apologize for not writing a text more to your liking. However, my goal has always been to teach those who don't already know assembly language, not extend the education of those who do. If you happen to fall into this category and you don't particularly like this text's presentation, there is some good news: there are dozens of texts on assembly language programming that use MASM and TASM out there. So you don't really need this one.
The first thing any instructor will notice when reviewing this text is that it's far too large for any reasonable course. That's because assembly language courses generally come in two flavors: a machine organization course (more hardware oriented) and an assembly language programming course (more software oriented). No text that is "just the right size" is suitable for both types of classes. Combining the information for both courses, plus advanced information students may need after they finish the course, produces a large text, like this one.
If you're an instructor with a limited schedule for teaching this subject, you'll have to carefully select the material you choose to present over the time span of your course. To help, I've included some brief notes at the beginning of each Volume in this text that suggests whether a chapter in that Volume is appropriate for a machine organization course, an assembly language programming course, or an advanced assembly programming course. These brief course notes can help you choose which chapters you want to cover in your course.
If you would like to offer hard copies of this text in the bookstore for your students, I will attempt to arrange with some "Custom Textbook Publishing" houses to make this material available on an "as-requested" basis. As I work out arrangements with such outfits, I'll post ordering information on Webster ( http://webster.cs.ucr.edu ). If your school has a printing and reprographics department, or you have a local business that handles custom publishing, you can certainly request copyright clearance to print the text locally.
If you're not taking a formal course, just keep in mind that you don't have to read this text straight through, chapter by chapter. If you want to learn assembly language programming and some of the machine organization chapters seem a little too hardware oriented for your tastes, feel free to skip those chapters and come back to them later on, when you understand the need to learn this information.
Programmed Introduction to MIPS Assembly Languange
Link To Content
This is a course in assembly language programming of the MIPS processor. It emphasizes the topics needed for study of computer architecture: bits, bit patterns, operations on bit patterns, and how bit patterns represent instructions and data. This course is equivalent to a semester-long junior college or university course (except, perhaps, for the emphasis on bit patterns).
The emphasis of the course is on understanding how computers work. This will provide a basis for further study of computer architecture and computer software. The MIPS processor, the subject of this course, has a well designed architecture and is particularly fruitful to study. However, the goal of the course is not to turn you into a MIPS programmer, but to give you an understanding of all computer systems.
The only equipment you need for this course is a PC. The only software you need is the SPIM simulator of the MIPS32 processor and a text editor. The simulator is available by free download (see appendix A). Example programs are presented using an MS Windows operating system. However, you can use any platform that runs SPIM. (There are many).
Assembly Language is normally taken the semester after a course in a high level programming language (such as Java or C). This course assumes that you have this background although no specific programming language is required.
Read the pages of this course actively. Think about and answer the question at the bottom of each page. (This style of tutorial is called programmed learning. It is very effective for technical material). Most questions call for just a little thought. Some call for pencil and paper. Keep a pencil and a scrap of paper next to your keyboard. Each chapter is about 15 pages long. Spend several minutes per page. You can read each chapter in about 30 minutes. However, for maximum benefit, you should run some of the example programs, write some programs of your own, and then think about your results. This may take several hours.
This is a course in assembly language programming of the MIPS processor. It emphasizes the topics needed for study of computer architecture: bits, bit patterns, operations on bit patterns, and how bit patterns represent instructions and data. This course is equivalent to a semester-long junior college or university course (except, perhaps, for the emphasis on bit patterns).
The emphasis of the course is on understanding how computers work. This will provide a basis for further study of computer architecture and computer software. The MIPS processor, the subject of this course, has a well designed architecture and is particularly fruitful to study. However, the goal of the course is not to turn you into a MIPS programmer, but to give you an understanding of all computer systems.
The only equipment you need for this course is a PC. The only software you need is the SPIM simulator of the MIPS32 processor and a text editor. The simulator is available by free download (see appendix A). Example programs are presented using an MS Windows operating system. However, you can use any platform that runs SPIM. (There are many).
Assembly Language is normally taken the semester after a course in a high level programming language (such as Java or C). This course assumes that you have this background although no specific programming language is required.
Read the pages of this course actively. Think about and answer the question at the bottom of each page. (This style of tutorial is called programmed learning. It is very effective for technical material). Most questions call for just a little thought. Some call for pencil and paper. Keep a pencil and a scrap of paper next to your keyboard. Each chapter is about 15 pages long. Spend several minutes per page. You can read each chapter in about 30 minutes. However, for maximum benefit, you should run some of the example programs, write some programs of your own, and then think about your results. This may take several hours.
PC Assembly Language
Link To Content
The tutorial has extensive coverage of interfacing assembly and C code and so might be of interest to C programmers who want to learn about how C works under the hood. All the examples use the free NASM (Netwide) assembler. The tutorial only covers programming under 32-bit protected mode and requires a 32-bit protected mode compiler.
I have example code files for: DJGPP, Borland, Microsoft, Open Watcom and Linux C compilers. The examples in the text of the tutorial are for DJGPP only, but how to interface with the other compilers is discussed as well. The example files also include macros that allow easy input/output and debugging (register dumps, memory dumps, coprocessor dumps and stack dumps). If you plan on running the examples inthe tutorial, you must download the appropriate example code file. It contains support files used by the examples in the tutorial (such as asm_io.inc).
Table of Contents
1. Introduction
2. Basic Assembly Language
3. Bit Operations
4. Subprograms
5. Arrays
6. Floating Point
7. Structures and C++
The purpose of this book is to give the reader a better understanding of how computers really work at a lower level than in programming languages like Pascal. By gaining a deeper understanding of how computers work, the reader can often be much more productive developing software in higher level languages such as C and C++. Learning to program in assembly language is an excellent way to achieve this goal. Other PC assembly language books still teach how to program the 8086 processor that the original PC used in
1981! The 8086 processor only supported real mode. In this mode, any program may address any memory or device in the computer. This mode is not suitable for a secure, multitasking operating system. This book instead discusses how to program the 80386 and later processors in protected mode
(the mode that Windows and Linux runs in). This mode supports the features that modern operating systems expect, such as virtual memory and memory protection. There are several reasons to use protected mode:
1. It is easier to program in protected mode than in the 8086 real mode that other books use.
2. All modern PC operating systems run in protected mode.
3. There is free software available that runs in this mode.
The lack of textbooks for protected mode PC assembly programming is the main reason that the author wrote this book.
As alluded to above, this text makes use of Free/Open Source software: namely, the NASM assembler and the DJGPP C/C++ compiler. Both of these are available to download from the Internet. The text also discusses how to use NASM assembly code under the Linux operating system and with Borland’s and Microsoft’s C/C++ compilers under Windows. Examples for all of these platforms can be found on my web site: http://www.drpaulcarter.com/pcasm. You must download the example code if you wish to assemble and run many of the examples in this tutorial.
Be aware that this text does not attempt to cover every aspect of assembly programming. The author has tried to cover the most important topics that all programmers should be acquainted with.
The tutorial has extensive coverage of interfacing assembly and C code and so might be of interest to C programmers who want to learn about how C works under the hood. All the examples use the free NASM (Netwide) assembler. The tutorial only covers programming under 32-bit protected mode and requires a 32-bit protected mode compiler.
I have example code files for: DJGPP, Borland, Microsoft, Open Watcom and Linux C compilers. The examples in the text of the tutorial are for DJGPP only, but how to interface with the other compilers is discussed as well. The example files also include macros that allow easy input/output and debugging (register dumps, memory dumps, coprocessor dumps and stack dumps). If you plan on running the examples inthe tutorial, you must download the appropriate example code file. It contains support files used by the examples in the tutorial (such as asm_io.inc).
Table of Contents
1. Introduction
2. Basic Assembly Language
3. Bit Operations
4. Subprograms
5. Arrays
6. Floating Point
7. Structures and C++
The purpose of this book is to give the reader a better understanding of how computers really work at a lower level than in programming languages like Pascal. By gaining a deeper understanding of how computers work, the reader can often be much more productive developing software in higher level languages such as C and C++. Learning to program in assembly language is an excellent way to achieve this goal. Other PC assembly language books still teach how to program the 8086 processor that the original PC used in
1981! The 8086 processor only supported real mode. In this mode, any program may address any memory or device in the computer. This mode is not suitable for a secure, multitasking operating system. This book instead discusses how to program the 80386 and later processors in protected mode
(the mode that Windows and Linux runs in). This mode supports the features that modern operating systems expect, such as virtual memory and memory protection. There are several reasons to use protected mode:
1. It is easier to program in protected mode than in the 8086 real mode that other books use.
2. All modern PC operating systems run in protected mode.
3. There is free software available that runs in this mode.
The lack of textbooks for protected mode PC assembly programming is the main reason that the author wrote this book.
As alluded to above, this text makes use of Free/Open Source software: namely, the NASM assembler and the DJGPP C/C++ compiler. Both of these are available to download from the Internet. The text also discusses how to use NASM assembly code under the Linux operating system and with Borland’s and Microsoft’s C/C++ compilers under Windows. Examples for all of these platforms can be found on my web site: http://www.drpaulcarter.com/pcasm. You must download the example code if you wish to assemble and run many of the examples in this tutorial.
Be aware that this text does not attempt to cover every aspect of assembly programming. The author has tried to cover the most important topics that all programmers should be acquainted with.
Beginners Introduction to the Assembly Language of ATMEL-AVR-Microprocessors
Link To Content
Why learning Assembler?
Assembler or other languages, that is the question. Why should I learn another language, if I already learned other programming languages? The best argument: while you live in France you are able to get through by speaking English, but you will never feel at home then, and life remains complicated. You can get through with this, but it is rather inappropriate. If things need a hurry, you should use the country's language.
Short and easy
Assembler commands translate one by one to executed machine commands. The processor needs only to execute what you want it to do and what is necessary to perform the task. No extra loops and unnecessary features blow up the generated code. If your program storage is short and limited and you have to optimize your program to fit into memory, assembler is choice 1. Shorter programs are easier to debug, every step makes sense.
Fast and quick
Because only necessary code steps are executed, assembly programs are as fast as possible. The duration of every step is known. Time critical applications, like time measurements without a hardware timer, that should perform excellent, must be written in assembler. If you have more time and don't mind if your chip remains 99% in a wait state type of operation, you can choose any language you want.
Assembler is easy to learn
It is not true that assembly language is more complicated or not as easy to understand than other languages. Learning assembly language for whatever hardware type brings you to understand the basic concepts of any other assembly language dialect. Adding other dialects later is easy. The first assembly code does not look very attractive, with every 100 additional lines programmed it looks better. Perfect programs require some thousand lines of code of exercise, and optimization requires lots of work. As some features are hardware-dependent optimal code requires some familiarity with the hardware concept and the dialect. The first steps are hard in any language. After some weeks of programming you will laugh
if you go through your first code. Some assembler commands need some months of experience.
AT90Sxxxx are ideal for learning assembler
Assembler programs are a little bit silly: the chip executes anything you tell it to do, and does not ask you if you are sure overwriting this and that. All protections must be programmed by you, the chip does anything like it is told. No window warns you, unless you programmed it before.
Basic design errors are as complicated to debug like in any other computer language. But: testing
programs on ATMEL chips is very easy. If it does not do what you expect it to do, you can easily add some
diagnostic lines to the code, reprogram the chip and test it. Bye, bye to you EPROM programmers, to the UV lamps used to erase your test program, to you pins that don't fit into the socket after having them removed some thousand times.
Changes are now programmed fast, compiled in no time, and either simulated in the studio or checked in circuit. No pin is removed, and no UV lamp gives up just in the moment when you had your excellent idea
about that bug
Why learning Assembler?
Assembler or other languages, that is the question. Why should I learn another language, if I already learned other programming languages? The best argument: while you live in France you are able to get through by speaking English, but you will never feel at home then, and life remains complicated. You can get through with this, but it is rather inappropriate. If things need a hurry, you should use the country's language.
Short and easy
Assembler commands translate one by one to executed machine commands. The processor needs only to execute what you want it to do and what is necessary to perform the task. No extra loops and unnecessary features blow up the generated code. If your program storage is short and limited and you have to optimize your program to fit into memory, assembler is choice 1. Shorter programs are easier to debug, every step makes sense.
Fast and quick
Because only necessary code steps are executed, assembly programs are as fast as possible. The duration of every step is known. Time critical applications, like time measurements without a hardware timer, that should perform excellent, must be written in assembler. If you have more time and don't mind if your chip remains 99% in a wait state type of operation, you can choose any language you want.
Assembler is easy to learn
It is not true that assembly language is more complicated or not as easy to understand than other languages. Learning assembly language for whatever hardware type brings you to understand the basic concepts of any other assembly language dialect. Adding other dialects later is easy. The first assembly code does not look very attractive, with every 100 additional lines programmed it looks better. Perfect programs require some thousand lines of code of exercise, and optimization requires lots of work. As some features are hardware-dependent optimal code requires some familiarity with the hardware concept and the dialect. The first steps are hard in any language. After some weeks of programming you will laugh
if you go through your first code. Some assembler commands need some months of experience.
AT90Sxxxx are ideal for learning assembler
Assembler programs are a little bit silly: the chip executes anything you tell it to do, and does not ask you if you are sure overwriting this and that. All protections must be programmed by you, the chip does anything like it is told. No window warns you, unless you programmed it before.
Basic design errors are as complicated to debug like in any other computer language. But: testing
programs on ATMEL chips is very easy. If it does not do what you expect it to do, you can easily add some
diagnostic lines to the code, reprogram the chip and test it. Bye, bye to you EPROM programmers, to the UV lamps used to erase your test program, to you pins that don't fit into the socket after having them removed some thousand times.
Changes are now programmed fast, compiled in no time, and either simulated in the studio or checked in circuit. No pin is removed, and no UV lamp gives up just in the moment when you had your excellent idea
about that bug
Assemblers And Loaders
Link To Content
Covering the design and implementation of assemblers and loaders, this comprehensive book opens with an introduction to one-pass and two-pass assemblers. Important concepts such as absolute and relocatable object files are discussed, as are assembler features such as local labels and multiple location counters. The format, meaning and implementation of many directives are look at in detail, and the important topics of macros and conditional assembly are introduced. The latter part of the book is concerned with the listing file, the properties of disassemblers and a look at three special types of assemblers. The book closes with a chapter on loaders and includes a very detailed example of the basic operation of a one-pass linking loader, together with other features and concepts such as dynamic loading, bootstrap loaders, and overlays. Lots of (solved) exercises are included throughout, and at the end of each chapter there are review problems and projects.
This book differs from the typical assembler text in that it is not a programming manual, and it is not concerned with any specific assembler language. Instead it concentrates on the design and implementation of assemblers and loaders. It assumes that the reader has some knowledge of computers and programming, and it aims to explain how assemblers and loaders work. Most of the discussion is general, and most of the examples are in a hypothetical, simple, assembler language. Certain examples are in the assembler languages of actual machines, and those are always specified. Some good references for specific assembler languages are [5, 6, 7, 13, 26, 27, 30, 31, 32, 35, 37, 39, 101].
This work has its origins at a point, a few years ago, when my students started complaining about a lack of literature in this field. Since I include assemblers and loaders in classes that I teach every semester, I responded by developing class notes. The notes were an immediate success, and have grown each semester, until I had enough material for an expository paper on the subject. Since I was too busy to polish the paper and submit it, I pretty soon found myself in a situation where the work was too large for a paper. So here it is at last, in the form of a book.
This is mostly a professional book, intended for computer professionals in general, and especially for systems programmers. However, it can be used as a supplementary text in a systems programming or computer organization class at any level.
Covering the design and implementation of assemblers and loaders, this comprehensive book opens with an introduction to one-pass and two-pass assemblers. Important concepts such as absolute and relocatable object files are discussed, as are assembler features such as local labels and multiple location counters. The format, meaning and implementation of many directives are look at in detail, and the important topics of macros and conditional assembly are introduced. The latter part of the book is concerned with the listing file, the properties of disassemblers and a look at three special types of assemblers. The book closes with a chapter on loaders and includes a very detailed example of the basic operation of a one-pass linking loader, together with other features and concepts such as dynamic loading, bootstrap loaders, and overlays. Lots of (solved) exercises are included throughout, and at the end of each chapter there are review problems and projects.
This book differs from the typical assembler text in that it is not a programming manual, and it is not concerned with any specific assembler language. Instead it concentrates on the design and implementation of assemblers and loaders. It assumes that the reader has some knowledge of computers and programming, and it aims to explain how assemblers and loaders work. Most of the discussion is general, and most of the examples are in a hypothetical, simple, assembler language. Certain examples are in the assembler languages of actual machines, and those are always specified. Some good references for specific assembler languages are [5, 6, 7, 13, 26, 27, 30, 31, 32, 35, 37, 39, 101].
This work has its origins at a point, a few years ago, when my students started complaining about a lack of literature in this field. Since I include assemblers and loaders in classes that I teach every semester, I responded by developing class notes. The notes were an immediate success, and have grown each semester, until I had enough material for an expository paper on the subject. Since I was too busy to polish the paper and submit it, I pretty soon found myself in a situation where the work was too large for a paper. So here it is at last, in the form of a book.
This is mostly a professional book, intended for computer professionals in general, and especially for systems programmers. However, it can be used as a supplementary text in a systems programming or computer organization class at any level.
Visual Basic Essentials
Link To Content
Visual Basic Essentials is intended to be of use to both novices looking to learn Visual Basic, and to those proficient in other languages who plan to cross-train. The Visual Basic language, combined with the Visual Studio, provides a uniquely powerful, yet easy to learn development environment allowing even the absolute beginner to rapidly create and deploy Windows applications.
Visual Basic Essentials begins with instruction on designing Windows forms in Visual Studio including tasks such as designing menu systems and toolbars and wiring up event procedures. The book then introduces the basic concepts of the Visual Basic language covering concepts such as Visual Basic variable types, looping, flow control, functions and subroutines. Once the basics are covered, topics such as single and mutli-dimensional arrays, string handling. File I/O and date and time manipulation are explained. Finally, more advanced topics such as Visual Basic object oriented programming, database access and graphics drawing are detailed.
Throughout the book, liberal use is made of code excerpts providing practical examples of theory in action. It is intended that having read this online book, the programmer will be confidently developing Windows applications using Visual Basic and Visual Studio.
Visual Basic Essentials is intended to be of use to both novices looking to learn Visual Basic, and to those proficient in other languages who plan to cross-train. The Visual Basic language, combined with the Visual Studio, provides a uniquely powerful, yet easy to learn development environment allowing even the absolute beginner to rapidly create and deploy Windows applications.
Visual Basic Essentials begins with instruction on designing Windows forms in Visual Studio including tasks such as designing menu systems and toolbars and wiring up event procedures. The book then introduces the basic concepts of the Visual Basic language covering concepts such as Visual Basic variable types, looping, flow control, functions and subroutines. Once the basics are covered, topics such as single and mutli-dimensional arrays, string handling. File I/O and date and time manipulation are explained. Finally, more advanced topics such as Visual Basic object oriented programming, database access and graphics drawing are detailed.
Throughout the book, liberal use is made of code excerpts providing practical examples of theory in action. It is intended that having read this online book, the programmer will be confidently developing Windows applications using Visual Basic and Visual Studio.
Labels:
and Lectures,
Documents,
Programming - .NET Books
Programming VB.NET: A Guide for Experienced Programmers
Link To Content
THIS BOOK IS A COMPREHENSIVE, hands-on guide to the Visual Basic .NET programming language addressed to readers with some programming background. No background in Visual Basic is required, however.
While I show you the syntax of VB .NET, this book is not designed to teach you syntax. I have taken this approach because trying to force VB .NET into the framework of older versions of VB is ultimately self-defeating—you cannot take advantage of its power if you continue to think within an older paradigm.
First off, I have tried to give you a complete treatment of object-oriented programming in the context of the VB .NET language. I feel pretty strongly that without a firm foundation here, it is impossible to take full advantage of the power that VB .NET can bring to you.
Also, I have tried to cover at the least the fundamentals of every technique that a professional VB .NET developer will need to master. This includes topics like multithreading, which are too often skimped on in most books. This does not mean that I cover all the possible (or even the majority of) applications of VB .NET to the .NET platform; that would take a book two or three times the size of this one. This is a book about the techniques you need to master, not the applications themselves. (I have tried to make most of the examples realistic, avoiding toy code as much as possible.)
Finally, since most people reading this book will have programmed with some version of Visual Basic before, I have also tried to be as clear about the differences between VB .NET and earlier versions of VB as I could. However, I want to stress that this book does not assume any knowledge of earlier versions of VB, just some programming experience.
THIS BOOK IS A COMPREHENSIVE, hands-on guide to the Visual Basic .NET programming language addressed to readers with some programming background. No background in Visual Basic is required, however.
While I show you the syntax of VB .NET, this book is not designed to teach you syntax. I have taken this approach because trying to force VB .NET into the framework of older versions of VB is ultimately self-defeating—you cannot take advantage of its power if you continue to think within an older paradigm.
First off, I have tried to give you a complete treatment of object-oriented programming in the context of the VB .NET language. I feel pretty strongly that without a firm foundation here, it is impossible to take full advantage of the power that VB .NET can bring to you.
Also, I have tried to cover at the least the fundamentals of every technique that a professional VB .NET developer will need to master. This includes topics like multithreading, which are too often skimped on in most books. This does not mean that I cover all the possible (or even the majority of) applications of VB .NET to the .NET platform; that would take a book two or three times the size of this one. This is a book about the techniques you need to master, not the applications themselves. (I have tried to make most of the examples realistic, avoiding toy code as much as possible.)
Finally, since most people reading this book will have programmed with some version of Visual Basic before, I have also tried to be as clear about the differences between VB .NET and earlier versions of VB as I could. However, I want to stress that this book does not assume any knowledge of earlier versions of VB, just some programming experience.
Labels:
and Lectures,
Documents,
Programming - .NET Books
Programmer's Heaven C# School Book
Link To Content
The Programmer's Heaven C# School book covers the .NET framework and the C# language. Starting with the basics of the language, it goes on to cover object oriented programming techniques and a wide range of C# languages features including interfaces, exceptions and delegates. Later chapters cover practical topics including database access with ADO.NET, building Windows forms applications, multi-threading and asynchronous I/O. The final chapter covers new features in C# 2.0, including generics.
Chapters
* Introduction
* C# Language Fundamentals
* Classes and Objects
* Inheritance & Polymorphism
* Structures, Enumeration, Garbage Collection & Nested Classes
* Abstract Classes & Interfaces
* Arrays, Collections & String Manipulation
* Exception Handling
* Delegates & Events
* WinForms & Windows Applications
* More Windows Controls & Standard Dialog Boxes
* Data Access using ADO.Net
* Multithreading
* The File System & Streams
* New Features In C# 2.0
The Programmer's Heaven C# School book covers the .NET framework and the C# language. Starting with the basics of the language, it goes on to cover object oriented programming techniques and a wide range of C# languages features including interfaces, exceptions and delegates. Later chapters cover practical topics including database access with ADO.NET, building Windows forms applications, multi-threading and asynchronous I/O. The final chapter covers new features in C# 2.0, including generics.
Chapters
* Introduction
* C# Language Fundamentals
* Classes and Objects
* Inheritance & Polymorphism
* Structures, Enumeration, Garbage Collection & Nested Classes
* Abstract Classes & Interfaces
* Arrays, Collections & String Manipulation
* Exception Handling
* Delegates & Events
* WinForms & Windows Applications
* More Windows Controls & Standard Dialog Boxes
* Data Access using ADO.Net
* Multithreading
* The File System & Streams
* New Features In C# 2.0
Labels:
and Lectures,
Documents,
Programming - .NET Books
Learn WPF In One Week
Link To Content
Synopsis:
Learn WPF in one Week
I started to build a one week training course to learn WPF. Starting with the basics and going through the important concepts of the framework up to more complex topics. I hope you like it.
Day 1 - Getting started
Install the development tools
Learn the basic concepts of WPF
Create your first WPF application
Learn how WPF changed the development workflow
Day 2 - Concepts of WPF
Get an introduction to XAML
Learn about the hierarchical relation of elements in WPF
Find out about the magic behind DependencyProperties
Get familiar with routed events.
Day 3 - Layout and Controls
Learn the layout basics
See the grid layout panel in action
Stack elements with the stackpanel
Get an overview about the variety of included controls.
Have a look at 3rd-party libraries
Day 4 - DataBinding and UI Architecture
Introduction to WPF DataBinding
How to display, sort and filter data
Using the Model-View-ViewModel Pattern
Learn how to validate user input
Create your own ValueConverter
Enhance the MVVM pattern by using Behaviors and Actions
Day 5 - Templates and Styles
Learn how to build rich user experience with WPF
Style the appearance of your controls
Completely replace the look of a control
How to display complex data in lists by using DataTemplates.
Synopsis:
Learn WPF in one Week
I started to build a one week training course to learn WPF. Starting with the basics and going through the important concepts of the framework up to more complex topics. I hope you like it.
Day 1 - Getting started
Install the development tools
Learn the basic concepts of WPF
Create your first WPF application
Learn how WPF changed the development workflow
Day 2 - Concepts of WPF
Get an introduction to XAML
Learn about the hierarchical relation of elements in WPF
Find out about the magic behind DependencyProperties
Get familiar with routed events.
Day 3 - Layout and Controls
Learn the layout basics
See the grid layout panel in action
Stack elements with the stackpanel
Get an overview about the variety of included controls.
Have a look at 3rd-party libraries
Day 4 - DataBinding and UI Architecture
Introduction to WPF DataBinding
How to display, sort and filter data
Using the Model-View-ViewModel Pattern
Learn how to validate user input
Create your own ValueConverter
Enhance the MVVM pattern by using Behaviors and Actions
Day 5 - Templates and Styles
Learn how to build rich user experience with WPF
Style the appearance of your controls
Completely replace the look of a control
How to display complex data in lists by using DataTemplates.
Labels:
and Lectures,
Documents,
Programming - .NET Books
Introducing Visual Basic 2005 for Developers
Link To Content
Get a focused, first look at the features and capabilities in Microsoft Visual Basic 2005, Visual Studio 2005, and the .NET Framework 2.0. If you currently work with Visual Basic 6, these authors fully understand the adoption and code migration issues you'll encounter. They'll step you through a quick primer on .NET Framework programming, offering guidance for a productive transition. If you already work with .NET, you'll jump directly into what's new, learning how to extend your existing skills. From the innovations in rapid application development, debugging, and deployment, to new data access, desktop, and Web programming capabilities, you get the insights and code walkthroughs you need to be productive right away.
Get a focused, first look at the features and capabilities in Microsoft Visual Basic 2005, Visual Studio 2005, and the .NET Framework 2.0. If you currently work with Visual Basic 6, these authors fully understand the adoption and code migration issues you'll encounter. They'll step you through a quick primer on .NET Framework programming, offering guidance for a productive transition. If you already work with .NET, you'll jump directly into what's new, learning how to extend your existing skills. From the innovations in rapid application development, debugging, and deployment, to new data access, desktop, and Web programming capabilities, you get the insights and code walkthroughs you need to be productive right away.
Labels:
and Lectures,
Documents,
Programming - .NET Books
Dissecting a C Sharp Application: Inside SharpDevelop
Link To Content
The SharpDevelop project started as a "one man show" in September of 2000, just a few months after
Microsoft released an Alpha of what was to become .NET 1.0 in early 2002. SharpDevelop is Mike
Krüger's brainchild, and he got started because he was disappointed with current programming
languages, and did want to try out the new programming language C#. As there was no really good
programming editor aside from betas of Visual Studio .NET – which he didn't have access to – he just
started to program what he needed.
The SharpDevelop core team – who wrote this book – consists of programmers who came aboard
during the Beta of .NET because they wanted to see how "real" Microsoft's new platform was and how
good or bad an experience it would be to program with it. Your best bet to learn a new platform is to
test it with an ambitious "proof of concept" project, and that is what SharpDevelop initially was:
pounding .NET and C# to see if it is viable in real-world applications.
Today, SharpDevelop is a full-featured Integrated Development Environment that leverages the features
of C# and .NET, and we can say that both met or exceeded our expectations for building powerful realworld
applications.
Over the course of more than two years of development, we learned a lot about this platform. This book
is about sharing our experience in building real applications using .NET and C#. You will learn about
design issues and decisions made, techniques and technologies used, as well as background information
on features of SharpDevelop that you won't usually find in everyday applications.
SharpDevelop is an evolving open-source application, with new features being added over time that are
not covered in this book. The code accompanying this book is available on the Apress web site.
You can always get the latest C# source code from http://www.icsharpcode.net/ ,compare it with the
code for this book and learn how code evolves and how we and our contributors implement new features.
The SharpDevelop project started as a "one man show" in September of 2000, just a few months after
Microsoft released an Alpha of what was to become .NET 1.0 in early 2002. SharpDevelop is Mike
Krüger's brainchild, and he got started because he was disappointed with current programming
languages, and did want to try out the new programming language C#. As there was no really good
programming editor aside from betas of Visual Studio .NET – which he didn't have access to – he just
started to program what he needed.
The SharpDevelop core team – who wrote this book – consists of programmers who came aboard
during the Beta of .NET because they wanted to see how "real" Microsoft's new platform was and how
good or bad an experience it would be to program with it. Your best bet to learn a new platform is to
test it with an ambitious "proof of concept" project, and that is what SharpDevelop initially was:
pounding .NET and C# to see if it is viable in real-world applications.
Today, SharpDevelop is a full-featured Integrated Development Environment that leverages the features
of C# and .NET, and we can say that both met or exceeded our expectations for building powerful realworld
applications.
Over the course of more than two years of development, we learned a lot about this platform. This book
is about sharing our experience in building real applications using .NET and C#. You will learn about
design issues and decisions made, techniques and technologies used, as well as background information
on features of SharpDevelop that you won't usually find in everyday applications.
SharpDevelop is an evolving open-source application, with new features being added over time that are
not covered in this book. The code accompanying this book is available on the Apress web site.
You can always get the latest C# source code from http://www.icsharpcode.net/ ,compare it with the
code for this book and learn how code evolves and how we and our contributors implement new features.
Labels:
and Lectures,
Documents,
Programming - .NET Books
Design and Implementation Guidelines for Web Clients
Link To Content
Most, if not all, applications require some level of user interaction. In today’s distributed applications, the code that manages this user interaction is in the presentation layer.
Most simple presentation layers contain user interface components, such as Microsoft® Windows Forms or ASP.NET Web Forms. These components typically contain code to perform functions such as configuring the visual appearance of controls; accepting and validating user input; and acquiring and rendering data from data access logic components or business components.
The presentation layer can also include user interface process components. User interface process components perform presentation layer tasks that are not directly concerned with user interactions. For example, user interface process components orchestrate the flow of control between forms in the presentation layer and coordinate background tasks such as state management and handling of concurrent user activities.
Design and Implementation Guidelines for Web Clients provides advice on how best to implement logic in the presentation layer of a distributed application. This guide is designed to accompany the User Interface Process Application Block; this application block provides a template implementation for user interface process components. For more information about how and when to use this block, see Chapter 2, “Using Design Patterns in the Presentation Layer,” in this guide. For more information about the application block, including download information, see User Interface Process Application Block Overview on MSDN.
The information in this guide is organized into the following chapters:
* This chapter introduces the topics in this guide and provides guidance on basic terminology. It also notes the decisions the authors of this guide assume you have already made.
Additionally, this chapter summarizes the key messages that are documented in detail elsewhere in this guide and describes how this guide fits into the Microsoft patterns & practices family of documentation.
* Chapter 2, “Using Design Patterns in the Presentation Layer,” describes how to separate the responsibilities of components in the presentation layers by using common design patterns.
Design patterns help you get a clean separation between the code that presents data to the user and accepts user interactions and the code that orchestrates the flow of control between forms and handles issues such as state management, data access, and asynchronous behavior in the presentation layer. By partitioning your code in this way, you can reduce the coupling between the various parts of your application, and thereby make your code easier to change and extend as requirements evolve.
Chapter 2 introduces a template implementation of the key design patterns. The template is included in the User Interface Process Application Block. Chapter 2 describes how to use this block as the basis for your own user interface code, thereby realizing the benefits described in the previous paragraph.
* Chapter 3, “Building Maintainable Web Interfaces with ASP.NET,” describes how to make ASP.NET code easier to implement and maintain. This chapter describes how to use custom controls to share specific behavior across multiple controls and how to use common page layouts to ensure there is a common appearance across all the pages in your Web site. This chapter also describes how to use inheritance appropriately and effectively in Web applications in order to reuse controls in the presentation layer.
* Chapter 4, “Managing Data,” describes the correct way for components in the user interface (UI) to access, present, update, and validate data input, and how the UI participates in maintaining data integrity.
The first of these topics, “Accessing and Representing Data,” compares and contrasts various techniques for accessing data in the presentation layer. This topic describes the best way to represent data in disconnected and streaming applications and how best to use transactions in the presentation layer. This topic also describes the importance of a layered approach to data access and how to use message-driven techniques, data access logic components, and business objects to access data in specific scenarios.
The second topic in the chapter, “Presenting Data Using Formatters, Data Binding, and Paging,” describes how to use .NET Framework formatter classes, data binding techniques, and paging to display data to the user.
The third topic in the chapter, “Supporting Data Updates from the Presentation Layer,” describes how the presentation layer can participate in updates to data in a back-end data store such as a relational database. This topic describes how to create data maintenance forms that let users create, read, update, and delete data entities either individually or as part of a list. It also describes how to increase productivity by implementing metadata-based forms that are sufficiently flexible to handle data in any structure.
The final topic in the chapter, “Validating Data in the Presentation Layer,” describes scenarios where data validation is appropriate in the presentation layer.
The presentation layer is the first line of defense against accidental or malicious rogue data from the user. This topic describes how and when to use .NET Framework validator controls to validate the format and content of input data and includes strategies for handling validation failures.
* Chapter 5, “Managing State in Web Applications,” describes the types of state used in the presentation layer and offers guidance about how to manage state in applications written for the Web. Correct state management is critical to the scalability and availability of Web applications.
For Web applications, this chapter discusses the pros and cons of storing per-user session data in the in-process Session object, the state server-based Session object, or the SQL Server-based Session object. This chapter also discusses how to use cookies, hidden form fields, URL rewiring, and the ASP.NET ViewState property as alternative ways to maintain state between pages in an ASP.NET Web application. Finally, it discusses how to use the Application object to share state between all users and sessions of an application.
* Chapter 6, “Multithreading and Asynchronous Programming in Web Applications,” describes how to increase performance and responsiveness of the code in the presentation layer by using multithreading and asynchronous programming. This chapter describes how to use .NET Framework thread pools to simplify multithreaded code in your application. In situations where the thread pool is inappropriate, the chapter describes how to manually create, manage, and synchronize threads in your code.
This chapter also describes how and when to use asynchronous method invocation, by using delegates. Delegates represent method calls on objects; with delegates, you can start methods asynchronously by using the BeginInvoke and EndInvoke delegate methods.
* Chapter 7, “Globalization and Localization,” describes how globalization and localization requirements affect the development of your presentation layers. This chapter addresses how the .NET Framework uses cultures to define language-specific and country-specific issues, such as number formats and currency symbols; it also describes how and when it might be useful to define alternative cultures programmatically.
Additionally, this chapter describes how to format various .NET Framework data types appropriately, according to the current culture. As part of this discussion, it describes how to create custom resource files to hold language-specific string resources and images.
* Appendix A, “Securing and Operating the Presentation Layer,” describes how security and manageability considerations affect the design of presentation layer components.
This appendix reviews the importance of authentication and authorization in the presentation layer and the options available for performing these tasks in various circumstances. Additionally, it describes how to improve the security of communications using Secure Sockets Layer (SSL), Internet Protocol Security (IPSec), and Virtual Private Networking (VPN).
This appendix also describes operational management issues as they pertain to the presentation layer. It describes how to manage exceptions in the presentation layer; health monitoring; and performance monitoring.
* Appendix B, “How To Samples,” provides code samples to illustrate the various techniques described throughout this guide.
Most, if not all, applications require some level of user interaction. In today’s distributed applications, the code that manages this user interaction is in the presentation layer.
Most simple presentation layers contain user interface components, such as Microsoft® Windows Forms or ASP.NET Web Forms. These components typically contain code to perform functions such as configuring the visual appearance of controls; accepting and validating user input; and acquiring and rendering data from data access logic components or business components.
The presentation layer can also include user interface process components. User interface process components perform presentation layer tasks that are not directly concerned with user interactions. For example, user interface process components orchestrate the flow of control between forms in the presentation layer and coordinate background tasks such as state management and handling of concurrent user activities.
Design and Implementation Guidelines for Web Clients provides advice on how best to implement logic in the presentation layer of a distributed application. This guide is designed to accompany the User Interface Process Application Block; this application block provides a template implementation for user interface process components. For more information about how and when to use this block, see Chapter 2, “Using Design Patterns in the Presentation Layer,” in this guide. For more information about the application block, including download information, see User Interface Process Application Block Overview on MSDN.
The information in this guide is organized into the following chapters:
* This chapter introduces the topics in this guide and provides guidance on basic terminology. It also notes the decisions the authors of this guide assume you have already made.
Additionally, this chapter summarizes the key messages that are documented in detail elsewhere in this guide and describes how this guide fits into the Microsoft patterns & practices family of documentation.
* Chapter 2, “Using Design Patterns in the Presentation Layer,” describes how to separate the responsibilities of components in the presentation layers by using common design patterns.
Design patterns help you get a clean separation between the code that presents data to the user and accepts user interactions and the code that orchestrates the flow of control between forms and handles issues such as state management, data access, and asynchronous behavior in the presentation layer. By partitioning your code in this way, you can reduce the coupling between the various parts of your application, and thereby make your code easier to change and extend as requirements evolve.
Chapter 2 introduces a template implementation of the key design patterns. The template is included in the User Interface Process Application Block. Chapter 2 describes how to use this block as the basis for your own user interface code, thereby realizing the benefits described in the previous paragraph.
* Chapter 3, “Building Maintainable Web Interfaces with ASP.NET,” describes how to make ASP.NET code easier to implement and maintain. This chapter describes how to use custom controls to share specific behavior across multiple controls and how to use common page layouts to ensure there is a common appearance across all the pages in your Web site. This chapter also describes how to use inheritance appropriately and effectively in Web applications in order to reuse controls in the presentation layer.
* Chapter 4, “Managing Data,” describes the correct way for components in the user interface (UI) to access, present, update, and validate data input, and how the UI participates in maintaining data integrity.
The first of these topics, “Accessing and Representing Data,” compares and contrasts various techniques for accessing data in the presentation layer. This topic describes the best way to represent data in disconnected and streaming applications and how best to use transactions in the presentation layer. This topic also describes the importance of a layered approach to data access and how to use message-driven techniques, data access logic components, and business objects to access data in specific scenarios.
The second topic in the chapter, “Presenting Data Using Formatters, Data Binding, and Paging,” describes how to use .NET Framework formatter classes, data binding techniques, and paging to display data to the user.
The third topic in the chapter, “Supporting Data Updates from the Presentation Layer,” describes how the presentation layer can participate in updates to data in a back-end data store such as a relational database. This topic describes how to create data maintenance forms that let users create, read, update, and delete data entities either individually or as part of a list. It also describes how to increase productivity by implementing metadata-based forms that are sufficiently flexible to handle data in any structure.
The final topic in the chapter, “Validating Data in the Presentation Layer,” describes scenarios where data validation is appropriate in the presentation layer.
The presentation layer is the first line of defense against accidental or malicious rogue data from the user. This topic describes how and when to use .NET Framework validator controls to validate the format and content of input data and includes strategies for handling validation failures.
* Chapter 5, “Managing State in Web Applications,” describes the types of state used in the presentation layer and offers guidance about how to manage state in applications written for the Web. Correct state management is critical to the scalability and availability of Web applications.
For Web applications, this chapter discusses the pros and cons of storing per-user session data in the in-process Session object, the state server-based Session object, or the SQL Server-based Session object. This chapter also discusses how to use cookies, hidden form fields, URL rewiring, and the ASP.NET ViewState property as alternative ways to maintain state between pages in an ASP.NET Web application. Finally, it discusses how to use the Application object to share state between all users and sessions of an application.
* Chapter 6, “Multithreading and Asynchronous Programming in Web Applications,” describes how to increase performance and responsiveness of the code in the presentation layer by using multithreading and asynchronous programming. This chapter describes how to use .NET Framework thread pools to simplify multithreaded code in your application. In situations where the thread pool is inappropriate, the chapter describes how to manually create, manage, and synchronize threads in your code.
This chapter also describes how and when to use asynchronous method invocation, by using delegates. Delegates represent method calls on objects; with delegates, you can start methods asynchronously by using the BeginInvoke and EndInvoke delegate methods.
* Chapter 7, “Globalization and Localization,” describes how globalization and localization requirements affect the development of your presentation layers. This chapter addresses how the .NET Framework uses cultures to define language-specific and country-specific issues, such as number formats and currency symbols; it also describes how and when it might be useful to define alternative cultures programmatically.
Additionally, this chapter describes how to format various .NET Framework data types appropriately, according to the current culture. As part of this discussion, it describes how to create custom resource files to hold language-specific string resources and images.
* Appendix A, “Securing and Operating the Presentation Layer,” describes how security and manageability considerations affect the design of presentation layer components.
This appendix reviews the importance of authentication and authorization in the presentation layer and the options available for performing these tasks in various circumstances. Additionally, it describes how to improve the security of communications using Secure Sockets Layer (SSL), Internet Protocol Security (IPSec), and Virtual Private Networking (VPN).
This appendix also describes operational management issues as they pertain to the presentation layer. It describes how to manage exceptions in the presentation layer; health monitoring; and performance monitoring.
* Appendix B, “How To Samples,” provides code samples to illustrate the various techniques described throughout this guide.
Labels:
and Lectures,
Documents,
Programming - .NET Books
Subscribe to:
Posts (Atom)