Using Aspect-Oriented Programming for Trustworthy Software Development [Hardcover]

Vladimir O. Safonov (Author)

Book Description

ISBN-10: 0470138173 | ISBN-13: 978-0470138175 | Publication Date: May 19, 2008 | Edition: 1

Learn how to successfully implement trustworthy computing tasks using aspect-oriented programming

This landmark publication fills a gap in the literature by not only describing the basic concepts of trustworthy computing (TWC) and aspect-oriented programming (AOP), but also exploring their critical interrelationships. The author clearly demonstrates how typical TWC tasks such as security checks, in-and-out conditions, and multi-threaded safety can be implemented using AOP.

Following an introduction, the book covers:

• Trustworthy computing, software engineering, and computer science

• Aspect-oriented programming and Aspect.NET

• Principles and case studies that apply AOP to TWC

Coverage includes Aspect.NET, the AOP framework developed by the author for the Microsoft.NET platform, currently used in seventeen countries. The author discusses the basics of Aspect.NET architecture, its advantages compared to other AOP tools, and its functionality. The book has extensive practical examples and case studies of trustworthy software design and code using the Aspect.NET framework. In addition, the book explores other software technologies and tools for using AOP for trustworthy software development, including Java and AspectJ.

This book also includes a valuable chapter dedicated to ERATO, the author's teaching method employed in this book, which has enabled thousands of students to quickly grasp and apply complex concepts in computing and software engineering, while the final chapter presents an overall perspective on the current state of AOP and TWC with a view toward the future.

Software engineers, architects, developers, programmers, and students should all turn to this book to learn this tested and proven method to create more secure, private, and reliable computing.

Editorial Reviews

From the Back Cover

Learn how to successfully implement trustworthy computing tasks using aspect-oriented programming

This landmark publication fills a gap in the literature by not only describing the basic concepts of trustworthy computing (TWC) and aspect-oriented programming (AOP), but also exploring their critical interrelationships. The author clearly demonstrates how typical TWC tasks such as security checks, in-and-out conditions, and multi-threaded safety can be implemented using AOP.

Following an introduction, the book covers:

• Trustworthy computing, software engineering, and computer science

• Aspect-oriented programming and Aspect.NET

• Principles and case studies that apply AOP to TWC

Coverage includes Aspect.NET, the AOP framework developed by the author for the Microsoft.NET platform, currently used in seventeen countries. The author discusses the basics of Aspect.NET architecture, its advantages compared to other AOP tools, and its functionality. The book has extensive practical examples and case studies of trustworthy software design and code using the Aspect.NET framework. In addition, the book explores other software technologies and tools for using AOP for trustworthy software development, including Java and AspectJ.

This book also includes a valuable chapter dedicated to ERATO, the author's teaching method employed in this book, which has enabled thousands of students to quickly grasp and apply complex concepts in computing and software engineering, while the final chapter presents an overall perspective on the current state of AOP and TWC with a view toward the future.

Software engineers, architects, developers, programmers, and students should all turn to this book to learn this tested and proven method to create more secure, private, and reliable computing.

About the Author

Vladimir O. Safonov, PhD, is Professor of the Computer Science Department at St. Petersburg University and the head of the university's Java Technology Laboratory. With some thirty years of experience leading major software projects, developing software, and teaching software technologies, Professor Safonov is one of the leading innovators in computer science and software engineering in Russia. He holds four U.S. software patents and four Russian software patents and has published five books and over eighty papers. He is also a Microsoft Research 2005/2006 RFP winner for TWC and Secure Software Development.

Product Details

• Hardcover: 338 pages
• Publisher: Wiley-Interscience; 1 edition (May 19, 2008)
• Language: English
• ISBN-10: 0470138173
• ISBN-13: 978-0470138175
• Product Dimensions: 6.4 x 0.9 x 9.5 inches
• Shipping Weight: 1.4 pounds (View shipping rates and policies)
• Average Customer Review: 4.6 out of 5 stars  See all reviews (5 customer reviews)
• Amazon Best Sellers Rank: #2,332,982 in Books (See Top 100 in Books)

More About the Author

I am Vladimir O. Safonov, professor of computer science and head of laboratory
at St. Petersburg University, Russia.
Please visit my personal Web page at http://www.vladimirsafonov.org to learn more about me.
My scientific areas of expertize are:
- compilers and programming languages
- aspect-oriented programming
- trustworthy computing
- knowledge management
- .NET
- Java
I am the author of the two Wiley books:
- Using aspect-oriented programming for trustworthy software development (2008)
- Trustworthy Compilers (2010)
and 120+ other scientific papers, including 5 more books (in Russian)and 4 USA software patents.
I am a fan of Mozart, poetry, history and architecture of my native city - the beautiful St. Petersburg.

Customer Reviews

Most Helpful Customer Reviews

2 of 2 people found the following review helpful:

4.0 out of 5 stars AOP programming history, language, and teaching method, September 24, 2008

By 

Robert Coleman (Yuba City, CA USA) - See all my reviews
(REAL NAME)   

This review is from: Using Aspect-Oriented Programming for Trustworthy Software Development (Hardcover)

A very interesting book, laid out using Professor Safanov's ERATO teaching technique, which in itself is an interesting subject. Following this technique we find a book that can be read on different levels and bringing different points into focus.

For instance, the history lesson that everything builds upon, while the information is available it is put in perspective and includes not only the "western" computer history but that of the Soviet Union. This "total" history builds a better picture of why we are at the point in computing that the Aspect methods and tools are extremely desirable. It also explains the supporting infrastructure in the current language sets that support moving to Aspect oriented programming.

Another "aspect" of the book goes on to provide lessons in the use of Aspect programming and to how and why the syntax has, and is, being developed.

Then a lesson in lesson planning and the use of the ERATO teaching method thus coming full circle.

A must read for those interested in where programming has come from, is going to and those who wish to communicate, that is teach, the whole versus the components in isolation.

2 of 2 people found the following review helpful:

4.0 out of 5 stars Teaching as well as using AOP, August 3, 2008

By 

J. Hirschfelder (Seattle, WA USA) - See all my reviews
(REAL NAME)   

This review is from: Using Aspect-Oriented Programming for Trustworthy Software Development (Hardcover)

This book is primarily about applications of aspect-oriented programming (AOP) to issues of "trustworthiness", specifically in the context of Microsoft's ".NET" architecture. It is not an introduction to AOP (despite sections on history and "AOP Basics"); there are many other books that address that market. Nor is it an introduction to software trustworthiness in general. Rather, the chapter on "Trustworthy Computing" is focused on Microsoft's "TWC initiative" of 2002, and on the features of the .NET framework that support that initiative.

Early implementations of AOP, most notably AspectJ, were based on Java. The author and his team at St. Petersburg University, supported by Microsoft, have developed an AOP implementation for .NET. The architecture of their AOP implementation is described in detail, and a variety of examples are presented. The core of the book, the chapter on applications of AOP to TWC, treats, among other topics: error handling, synchronization, multithreading, privacy, reliability, and design-by-contract. Quantitative estimates of effects of AOP on efficiently and performance are provided. These estimates are based on a variety of assumptions which may be optimistic; and in fact the impacts of AOP on performance and on programmer productivity are an area in which much additional research is needed.

The final major chapter, "Teaching TWC and AOP", reads like a separate book, and perhaps should have been. Here the author explains his teaching philosophy and methods, and provides detailed descriptions of AOP-related courses from the computer science curricula at St. Petersburg University, with specific course descriptions, topic lists, and even abbreviated lecture notes. This chapter could be a fertile source of ideas for any faculty planning similar courses or curricula.

The author has been extremely thorough in citing the literature; in fact, one of the side effects of reading this book was a tour through the earlier and current treatments and implementations of AOL. Over 160 references are listed, of which over half are web links (some of which, not surprisingly, are already dead).

An appendix provides five complex examples of AOP applications, with explanations and complete, fully tested source code.

Although not directed to the beginner, this book would be a valuable reference for programmers with some previous AOP experience (due to the excellent examples), and for university curriculum developers.

1 of 1 people found the following review helpful:

5.0 out of 5 stars TWC and AOP, August 17, 2008

By 

John Spencer (Chelan, WA USA) - See all my reviews
(REAL NAME)   

This review is from: Using Aspect-Oriented Programming for Trustworthy Software Development (Hardcover)

The book,using AOP for TWC is an excellent entry for teaching. I especially thought the background information leading up to Microsoft's TWC initiative was exceptionally thorough and provided an excellent backdrop for advanced students learning AOP.

It is my opinion that the author was trying to not only expose the need for TWC-like efforts but additionally give the reader or lecturer the correct guidance and tools to build a effective class series. I had no problem with the authors focus on the .NET framework and the AOP implementations - this focus was well thought-out and thorough.

Teaching TWC or TWC principles should be a must in any current CS curriculum. Professor Safonov I believe has created an excellent gateway publication for advanced university students and provide an excellent foundation for lecturers to build upon. I especially liked the structure of the chapter on 'Teaching TWC and AOP' which I believe is an excellence structure for developers as well as students.

I highly recommend this book.