Register your product to gain access to bonus material or receive a coupon.
Visual Basic .NET Style Guide, The: The Essential Companion for Development Teams and Individuals
- By Tim Patrick
- Published Dec 7, 2001 by Pearson.
Book
- Sorry, this book is no longer in print.
About
Features
- NEW - Extensive .NET coverage—Thoroughly updates the industry's #1 Visual Basic style guide to reflect the significant changes Microsoft has introduced with VB.NET, including new syntax, new feature interactions, external .NET libraries, user interface standards, ADO.NET usage, and more.
-
Ensures that students stay ahead of the curve, by introducing them to the version of Visual Basic that will become increasingly dominant over the next several years. Ex.___
-
- NEW - VB.NET keyword reference—Includes new keyword reference reflecting the latest VB.NET enhancements and extensions.
-
Gives students a quick-reference style source for the most important new VB.NET language elements. Ex.___
-
- Best practices for Visual Basic.NET development—Offers solutions proven to help developers and teams create code more quickly, effectively, and reliably—and build systems that are far easier to maintain.
-
Helps students learn the right way to code—and to work together in development teams—so they don't have to learn these skills through trial-and-error. Ex.___
-
- Extensive coverage of team-based development—Includes detailed chapters on discipline, planning, and ethics.
-
Ensures that students will be prepared for both the technical and human side of team-based software development. Ex.___
-
- Detailed coverage of commenting—Presents invaluable techniques for helping students write code others can understand and maintain.
-
Shows students a consistent, effective way to comment their code. Ex.___
-
Description
- Copyright 2002
- Edition: 1st
- Book
- ISBN-10: 0-13-034862-7
- ISBN-13: 978-0-13-034862-3
Powerful, elegant, professional code — it's all a matter of style!
- Improve and simplify your work by learning the elements of professional coding
- Build powerful, reliable, and maintainable applications through consistent practices
- Acquire the mindset of a professional developer
Visual Basic programming is simple enough, but this simplicity can encourage poor programming habits. If you want to produce code that is professional inside and out, you need to do it with a consistent style. Whether you work alone or with a group, you know that clear coding and concise documentation can streamline your job. In The Visual Basic .NET Style Guide, author Tim Patrick teaches you how to structure your projects so they'll satisfy the user immediately, and be easy to troubleshoot or modify later on. You'll also learn to give your applications a polished, professional look: With consistent interface guidelines, your projects are easier to use and more pleasing to the eye, which is something your audience will notice right away.
The Visual Basic .NET programming environment introduces powerful object-oriented and Internet-savvy features. In this edition of The Visual Basic .NET Style Guide, Patrick uses real code examples to show you how to harness these tools using a disciplined approach, whether updating existing code or building new applications from scratch. The Visual Basic .NET Style Guide will teach you to
- Write clear, concise code that's easy for you and others to maintain
- Fine-tune your interface for a rich, rewarding user experience
- Learn the foundational attitudes of discipline, planning, and ethics
- Apply the power of Visual Basic .NET to new and existing software
Even if your experience in Visual Basic and object-oriented programming is limited, The Visual Basic .NET Style Guide will teach you to write concise, easily maintained code that fully leverages the .NET platform.
Sample Content
Online Sample Chapter
Becoming a Professional VB.NET Developer with Style
Table of Contents
Preface.
I. STRUCTURE.
1. Professional Programming as Style.2. Using Declaration.
3. Commenting and Style.
4. User Interface Consistency.
5. Documentation.
II. FOUNDATION.
6. Discipline.7. Planning.
8. Ethics.
III. STANDARDS.
9. Declaration Standards.10. Keyword Reference.
11. Control and User Interface Standards.
12. Database Standards.
Preface
Preface
I still remember the first computer program I wrote. I composed it while standing in front of a TRS-80 at a Radio Shack store in Missoula, Montana. Then a 12-year-old, I had just seen my first "real" computer a few weeks earlier in my classroom. Our teacher taught us everything that he knew about the computer over one or two days, and I was fascinated. Cautiously I approached the sleek gray terminal with its glowing phosphor screen. With excitement welling up inside of me, I set my mind on the task at hand, reached out for the keyboard, and programmed my first software application.
10 FOR I = 1 TO 100020 PRINT I, I + 130 NEXT I40 END
It may seem infantile, especially when you consider what you can do with the same amount of code in some more modern languages. But for a seventh grader with his first chance to write a real program, it was grand. It opened a whole new world for me. I can still recall the feeling I had as I stood there, watching the columns of numbers racing down the screen. That same feeling comes back to me every time I write a working program.
Over the years I have learned to write programs longer than four lines. I took the standard academic and business path through PASCAL, 8086 assembly language, LISP, C, and C++, but today I spend most of my programming career with a variant of the language that my fingers first typed: Microsoft Visual Basic .NET. And why not? Visual Basic .NET allows me to write complex applications for Microsoft Windows in a fraction of the time that it would take me to write the same programs in C++ or C#, with or without the Windows Forms or Web Forms class libraries. Visual Basic .NET makes the creation of Windows and Web-based applications literally child's play. However, along with the ease of programming has come the ease of writing bad programs.
In the early days of computers, the skill of programming was limited to a few geeks who spent their lives cooped up in a stadium-sized computer room with a brain the size of a four-function calculator (the computer's brain, not the geeks'). These progenitors of modern software engineers spent hours choosing just the right punch cards to calculate p to 10 decimal places. The most powerful computers of the time were expensive, slow, and short on memory. It was in the programmer's (and his employer's) best interest to write well-crafted, concise, and error-free code the first time. Style was not an issue; if it worked, it was good enough.
Today the computing horizon is quite different. Once there were a few ENIAC-shaped mud huts; now Pentium-class high-rises dot the landscape. The latest machines are orders of magnitude faster than anything imaged by Charles Babbage, and they are priced within the budget of most technology-crazed consumers. The modern business climate requires that the average person understand how to operate a computer. With the advent of (relatively) easy-to-use programming languages such as BASIC, some employers are asking their business experts to translate that business knowledge into working computer applications.
Consider the case of Joe, an accountant for a small manufacturing company. Joe has worked for years literally "keeping the books." One day, Joe's supervisor, knowing that Joe is the resident expert on accounting practices, presents him with an IBM PC and a copy of dBase II. Daunted at first, Joe digs into the database, and after months of feverish activity, shows off his new accounting package.
No one is more surprised than Joe to find that the program actually does accounting. Still, he knows that it is not quite right, and it is always a few dollars and cents off at the end of the month. Over the next few years Joe works hard at fixing and improving the program, as well as writing numerous reports demanded by various departments. Finally the day comes for Joe to retire, and Sue, his assistant, is given the keys to the dBase program. Along with those keys Sue receives a "good luck" from Joe, but scant information about how the program works.
You already know the rest of the story. The program is in a hideous state of disrepair, but since Sue is as much a novice as Joe was, she is at a loss as to how to fix the application. If this story was unique we would simply sigh and say, "Oh, poor Sue." But this situation happens on a daily basis across the computer world. Instead of pity for Sue, we often have to console ourselves.
Obscure programming practices are not limited to untrained business users. Programming students are often tempted with languages that invite them to write strange source code. One of the first languages I used in school was a flavor of BASIC found on the PDP 11/70-hosted operating system RSTS/E. This version of BASIC did not require white space to be placed between most language constructs. Therefore, it was possible to write the same four-line program shown earlier using a single, compressed statement.
FORI=1TO1000\PRINTI,I+1\NEXTI\END
It even allowed this reversed syntax:
PRINTI,I+1FORI=1TO1000
Imagine entire applications written in this compressed format! Because the interpreter focused on the extraction of known keywords from any statement, it allowed the programmer to write very unsightly code that did not run any faster than the equivalent code with white space included. Consider the following program:
10A$(I)=" "FORI=1TO9\B$="-+-+-"\C$="|"\X=1\R$=""\T=020GOSUB50025IFX=1THENPRINT"YOUR TURN:";ELSEPRINT"TRY AGAIN:";30INPUTQ$\P=INT(Q$)\X=2\IFA$(P)<>" "THENGOTO2040X=1\A$(P)="X"\T=T+150GOSUB1000\IFR$="X"THENPRINT"YOU WIN!"\GOTO1060IFT=9THENPRINT"DRAW"\GOTO1070M=INT(RND(9))\IFA$(M)<>" "THENGOTO70\A$(M)="O"80GOSUB1000\IFR$="O"THENGOSUB500\PRINT"I WIN!"\GOTO1090GOTO20500PRINT"BOARD LEGEND"\FORC1=1TO3510PRINTA$(((C1-1)*3)+1);C$;A$(((C1-1)*3)+2);515PRINTC$;A$(((C1-1)*3)+3);520PRINT" ";((C1-1)*3)+1;C$;525PRINT((C1-1)*3)+2;C$;((C1-1)*3)+1530IFC1<3THENPRINTB$540NEXTC1\RETURN1000RESTORE\R$=""\FORC1=1TO8\READT1\READT2\READT31010Q$=A$(T1)+A$(T2)+A$(T3)1015IFQ$="XXX"THENR$="X"\IFQ$="OOO"THENR$="O"1020NEXTC1\RETURN1030DATA1,2,3,4,5,6,7,8,9,1,4,7,2,5,8,3,6,9,1,5,9,3,5,7
I am sure that you will soon figure out the purpose of this application. (See the answer at the end of this Preface just to be sure.) Can you picture an entire business application written in this style? Can you picture yourself being asked to fix such an application?
Visual Basic .NET is a little more strict in the area of statement formatting, but it is still possible to write programs that are both internally (code) and externally (user interface) displeasing. When I was taking programming classes in school, I thought it was clever to write obfuscated code in this manner.1 This feeling ended when, in my first programming job, I was asked to fix someone else's muddled application. From that point on I was committed to writing clear, concise, and readable code that was pleasing both for the programmer and for the user. This book is a guide to help you travel this same path. In this text you will find a clear differentiation between unprofessional programs--those that are aesthetically and logically annoying to both the user and other programmers that may review the code--and professional programs.
Who Is This Book For?
This book is for everyone who cares about Visual Basic .NET applications, and the development process surrounding these applications. Over the years, Microsoft Visual Basic has been very popular. Near the language's tenth anniversary in 2001, Microsoft boasted more than three million developers using the language.2 This number includes weekend programmers with little or no training in programming practices. You can walk into any major bookseller and see shelf after shelf of books with names like Learn Visual Basic in Your Sleep and Visual Basic .NET in 21 Minutes. These books are great for learning the usage and syntax of Visual Basic, but they often fall short when it comes to training the eager developer how to program well. The Visual Basic .NET Style Guide is written for the Visual Basic .NET programmer who wishes to enhance his or her professional and technical programming methods and style. If you are such a programmer, read on!
Writing professional Visual Basic .NET programs does take effort, lots of effort. Still, effort alone will not bring about the quality that you seek. This book contains lists of guidelines for writing good Visual Basic .NET programs. Yet more than that, it promotes an attitude, an environment of the mind in which healthy Visual Basic .NET programs are formed.
Visual Basic and Visual Basic .NET
Visual Basic 1.0 was a crossover language between MS-DOS and Windows, but it had serious platform limitations. The growing success of each release of Visual Basic, and its Visual Basic for Applications variant, has made it the language of choice for software solutions. Today's Visual Basic .NET is the most powerful version of the language yet released. With its integration into the .NET Framework, Visual Basic boasts virtually all of the power and features of C++, and its offspring, C#. While much of the information found in The Visual Basic .NET Style Guide is relevant to previous versions of the language, the book is primarily designed for use with the initial and subsequent releases of Visual Basic .NET.
Throughout this book, the terms "Visual Basic" and "Visual Basic .NET" are used interchangeably. In those few cases where "Visual Basic" refers to a version of the language before the introduction of the .NET Framework, the context of the sentence will make that clear.
P.S. The program listed earlier is a tic-tac-toe game.