 |
|
 |
|
|
|
|
|
Download Now! (461 KB, Updated: 10/10/ 2008)
We all know we should test our code more thoroughly, but who has the time and patience, and isn't our code "good enough" anyway? Did you know that that is widely accepted that if you have a program of 500 lines, you should expect to write 5000 lines of test code? Ah, so that's why we don't test our code! If you are not satisfied with the number of bugs in your code or if you sometimes find yourself embarrassed demonstrating your software to users, then attend this session to learn how you can automate the testing process, reduce bugs in your code, and increase confidence in your applications. This session reviews the tools, from open source to commercial, that offer varying levels of testing automation.
|
|
|
|
|
|
|
|
|
|
|
|
|
Download Now! (1.7 MB, Updated: February 8, 2008)
Over its lifetime, PL/SQL has grown increasingly robust and complex. Many programmers are barely aware of the new capabilities of PL/SQL, much less fully understand the implications for their programs. And virtually all PL/SQL developers are too pressured by deadlines to have the time to think through the best way to apply PL/SQL's many features.
Steven Feuerstein, one of the world's leading experts in the Oracle PL/SQL language, has studied PL/SQL for over 12 years and has developed a deep understanding of how best to build applications with this language.
The High Quality Programming seminar will focus on critical areas of development:
- Writing SQL in PL/SQL: SQL statements lie at the heart of any PL/SQL application and PL/SQL makes it incredibly easy to write that SQL. This means that most of us take SQL totally for granted, which is a big mistake, since SQL statements are the slowest elements of our code and often need changing. Steven will show you how to take advantage of best features of PL/SQL for writing SQL and also offer best practices for writing SQL statements that can be more easily maintained and optimized.
- Optimizing performance of PL/SQL applications: beyond SQL, there are many concerns and ways to improve the performance of one's PL/SQL code. From new features to the careful application of long-standing features, Steven will show you how to analyze code performance and, at least in some cases, improve it by one or more orders of magnitude.
- Unit testing PL/SQL programs: let's face it, few of us test our code sufficiently. Who has the time? And how are you supposed to write that code, anyway? In this section of the course, Steven offers "six simple steps to unit testing happiness" that will utterly transform the quality and quantity of your PL/SQL testing.
- Building modular, reusable code: just say "no"....to spaghetti code that is impossible to read, maintain, or enhance. In this section, Steven will show you how to take advantage of packages, local subprogram units, cursor variables, autonomous transactions, and more to craft small, reusable units of code.
- Error management: every well-crafted application follows a standard, consistent process for handling, raising and reporting errors. PL/SQL offers a powerful, flexible exception handling architecture, but it has its weaknesses. Steven will show you how to compensate for those weaknesses, take advantage of the latest error management features, and build a reusable package to log and raise exceptions.
Prerequisites
You should have a working knowledge of PL/SQL and at least a year's worth of experience with the language. All developers, from beginner to expert, will benefit from Steven's ideas and examples.
|
|
|
|
|
|
|
|
|
|
|
|
|
Download Now! (2.3 MB, Updated: September 17, 2007)
We all hear about (and some of us write about) "best practices". But sometimes all that advice can be quite overwhelming and not very practical. This two hour seminar offers advice for writing the best PL/SQL of your life which I believe is thoroughly practical and instantly applicable to your professional lives as PL/SQL developers
"Practical Best" starts of by recommending a high-level workflow for building applications in three phases: prepare, construct and validate. Within preparation, I focus on how you should establish a solid foundation for development by standardizing (set the rules), systematize (follow the rules with formal processes), and automate (implement the rules automatically as much as possible). The main focus in this section is on how to best write SQL inside PL/SQL. And here I do my first PL/SQL magic trick: I convince you that SQL IS BAD!
From there, we shift focus to single program construction. I go into a detailed workflow at this level, emphasizing preparation, review, optimization and testing. And then I spend LOTS of time talking about how to improve the way we test our code, which brings me to my second PL/SQL magic trick: I will convince you that TESTING IS (CAN BE) FUN!
And throughout the seminar, I provide or point you to scripts, utilities and tools to help you quickly apply my advice.
|
|
|
|
|
|
|
|
|
|
|
|
|
Download Now! (1.9 MB, Updated: January 28, 2008)
Over its lifetime, PL/SQL has grown increasingly robust and complex. Many programmers are barely aware of the new capabilities of PL/SQL, much less fully understand the implications for their programs. And virtually all PL/SQL developers are too pressured by deadlines to have the time to think through the best way to apply PL/SQL's many features.
This two-day seminar teaches attendees about the most important features of the PL/SQL language, focusing on the major advances in Oracle 9i Database and Oracle Database 10g. Steven then takes you beyond the basics to show you how to apply these features in the context of best practices, so that you write highly optimized and easily maintained and enhanced applications.
After attending this seminar, you will be ready and able to:
- Improve query and DML performance by an order of magnitude or more with BULK COLLECT, FORALL and PL/SQL collections (array-like structures).
- Unit test your PL/SQL subprograms like never before, utilizing the processes and tools Steven offers in his "six simple steps to unit testing happiness."
- Optimize the construction of your SQL statements in PL/SQL programs, both from the standpoint of performance and maintainability.
- Build modular, reusable code: Steven will show you how to take advantage of packages, local subprogram units, cursor variables, autonomous transactions, and more to craft small, reusable units of code.
- Manage errors by following a standard, consistent process for handling, raising, and reporting errors.
- Apply collections (a critical but under-utilized data structure) to solve a wide variety of problems, from slow query performance to mutating table trigger errors.
- Take advantage of both forms of dynamic SQL in PL/SQL to write the kind of flexible programs that are required in a world driven by the Internet.
Prerequisites
You should have a working knowledge of PL/SQL and at least a year's worth of experience with the language. All developers, from beginner to expert, will benefit from Steven's ideas and examples.
Oracle Version
Steven will demonstrate techniques and principles that apply to all versions of Oracle, but will also showcase new features in Oracle Database 10g that can dramatically improve the quality and performance of code that you write. Download Now! (.85 MB, Updated: May 13, 2006)
|
|
|
|
|
|
|
|
|
|
|
|
|
Full Day Seminar - Download Now! (.75 MB, Updated: May 04, 2006)
Two Hour Presentation - Download Now! (1.1MB, uploaded on April 5, 2007)
Designed especially for Oracle Scandinavia, Best Practice PL/SQL with Steven Feuerstein is a one-day whirlwind guide to the best that PL/SQL has to offer and the best practices for writing faster, more modular and eminently maintainable applications.
Over its lifetime, PL/SQL has grown increasingly robust and complex. Many programmers are barely aware of the new capabilities of PL/SQL, much less fully understand the implications for their programs. And virtually all PL/SQL developers are too pressured by deadlines to have the time to think through the best way to apply PL/SQL's many features.
Steven Feuerstein, one of the world's leading experts in the Oracle PL/SQL language, has studied PL/SQL for over 12 years and has developed a deep understanding of how best to build applications with this language. He will share what he has learned with Oracle technologists in Scandinavia in May 2006.
The Best Practice PL/SQL one-day seminar will focus on N critical areas of development:
- Writing SQL in PL/SQL: SQL statements lie at the heart of any PL/SQL application and PL/SQL makes it incredibly easy to write that SQL. This means that most of us take SQL totally for granted, which is a big mistake, since SQL statements are the slowest elements of our code and often need changing. Steven will show you how to take advantage of best features of PL/SQL for writing SQL and also offer best practices for writing SQL statements that can be more easily maintained and optimized.
- Optimizing performance of PL/SQL applications: beyond SQL, there are many concerns and ways to improve the performance of one's PL/SQL code. From new features to the careful application of long-standing features, Steven will show you how to analyze code performance and, at least in some cases, improve it by one or more orders of magnitude.
- Unit testing PL/SQL programs: let's face it, few of us test our code sufficiently. Who has the time? And how are you supposed to write that code, anyway? In this section of the course, Steven offers "six simple steps to unit testing happiness" that will utterly transform the quality and quantity of your PL/SQL testing.
- Building modular, reusable code: just say "no"....to spaghetti code that is impossible to read, maintain, or enhance. In this section, Steven will show you how to take advantage of packages, local subprogram units, cursor variables, autonomous transactions, and more to craft small, reusable units of code.
- Error management: every well-crafted application follows a standard, consistent process for handling, raising and reporting errors. PL/SQL offers a powerful, flexible exception handling architecture, but it has its weaknesses. Steven will show you how to compensate for those weaknesses, take advantage of the latest error management features, and build a reusable package to log and raise exceptions.
Prerequisites
You should have a working knowledge of PL/SQL and at least a year's worth of experience with the language. All developers, from beginner to expert, will benefit from Steven's ideas and examples.
Oracle Version
Steven will demonstrate techniques and principles that apply to all versions of Oracle, but will also showcase new features in Oracle Database 10g that can dramatically improve the quality and performance of code that you write.
|
|
|
|
|
|
|
|
|
|
|
|
|
Download Now! (1.2MB, Updated: April 18, 2007)
Sure, there's an awful lot you can do and write and accomplish with PL/SQL. There's also, however, an awful lot that you should NEVER do or write or try to accomplish in PL/SQL. This presentation will showcase the "top ten" things to avoid when building a PL/SQL-based application (warning: lots of it is thoroughly tongue-in-cheek!). If you have ideas of your own on this matter, please send them along to Steven at steven@stevenfeuerstein.com and perhaps they will be highlighted in a future iteration of this presentation!
Everybody goes on and on about "best practices." We all know, however, that we just don't have time to remember all those important things that we SHOULD do. We are, on the other hand, terrified that someone else will look at our code and laugh at something we did that is just ridiculous and wrong. Fear of embarrassment is a powerful motivator for smart people like PL/SQL programmers, so Steven will use that approach in this presentation with the hopes that maybe THIS time attention will be paid and habits of programming modified!
|
|
|
|
|
|
|
|
|
|
|
|
|
Download Now! (.7 MB, Updated March 2005)
- MIN-imize bugs!
- MIN-imize maintenance!
- MAX-imize productivity!
- MAX-imize quality of programming life!
MIN-MAX PL/SQL offers a comprehensive treatment of tips and techniques that will improve the performance and maintainability of your PL/SQL programs. While there are a number of tools that help you tune the SQL side of your application, PL/SQL tuning has been largely ignored -- and is largely up to the individual programmer to make happen. This seminar will show you how to take advantage of high performance PL/SQL features such as bulk array processing in dynamic SQL and data caching in packages. Define your variable data structures for top efficiency. Tuned code is, of course, just one component of high-quality software. This seminar also helps you build that can be maintained effectively, is thoroughly tested and handles error robustly.
Topics include...
Writing Maintainable Code: Most of us are so deadline driven that we end up writing code that might, if we are lucky, meet today's requirements. We (or those who take over responsibility for our code) almost never write code that can be easily modified and enhanced over time -- even though that's where most of the work will happen. This seminar demonstrates a variety of techniques and standards that will allow you to both complete projects on time and maintain them effectively over time.
Effective Unit Testing: A unit test is a test that a developer creates to ensure that his or her "unit", usually a single program, works properly. A unit test is very different from a system or functional test; these latter types of test are oriented to application features or overall testing of the system. You cannot properly or effectively perform a system test until you know that the individual programs behave as expected. So of course you would therefore expect that programmers do lots of unit testing and have a correspondingly high level of confidence in their programs. Ah, if only that were the case! This seminar shows you how to improve dramatically the quantity and quality of unit testing -- and do it with a light-weight methodology and pre-built PL/SQL framework.
Developing an Exception Handling Architecture: Trapping and handling errors is a crucial, but neglected, aspect of any PL/SQL application. This section explores the features of PL/SQL exception handling, identifies common problems with coding for exceptions, and offers an architecture for consistent error handling throughout your code.
Writing SQL in PL/SQL: It's very easy -- perhaps too easy -- to write SQL into your PL/SQL application. Unfortunately, your data structures are always changing -- and breaking your code. This section shows how to write SQL in PL/SQL so that your code base adapts easily (in many cases, automatically) to changes in the data design.
Tuning Algorithms: It is really, really hard to tune PL/SQL code because it is not a structured language, in the same sense as SQL. Most PL/SQL programs consist of algorithms (formulas you devise to solve a problem). There are many different ways to write "correct" algorithms (they do the right thing or returnt he right answer), but many of those algorithms will perform poorly. This seminar offers tips on how to identify problem algorithms and how to straighten them out.
Strategies for Implementing Best Practices: It's not enough to be handed a long list of "shoulds" and "should nots". You've got to figure out a way to make it easier for developers to follow the best practices. This section explores several topics, from code generation to conformance scripts.
|
|
|
|
|
|
|
|
|
|
|
|
|
|