book

AspectJ in Action, Second Edition

Name: AspectJ in Action, Second Edition
Author: Ramnivas Laddad
ISBN: 9781933988054

by Ramnivas Laddad

August 2009

Intermediate to advanced

568 pages

14h 23m

English

Manning Publications

Read now

Unlock full access

Praise for the First Edition
More Praise for the First Edition
Copyright
Foreword
Preface
Preface to the first edition
Acknowledgments
About this book
RoadmapWho should read this bookCode and typographical conventionsGetting the source codeAuthor onlineAbout the author
About the title
About the cover illustration

A real-world perspective of AOP
Mapping AOP onto the hype cycleTechnology triggerPeak of inflated expectationsTrough of disillusionmentSlope of enlightenmentRESPONSE TO USER NEEDSFOCUSED CONTEXT: THE SPRING FACTORAVAILABILITY OF A GRADUAL ADOPTION PATHNEW JVM LANGUAGESACCEPTANCE OF ANNOTATIONSDISILLUSIONMENT FROM THE ALTERNATIVE TECHNOLOGIESPlateau of productivityWhere is AOP being used?Enterprise applicationsWeb and application serversApplication frameworksMonitoring toolsCompiler and IDE integration
1. Understanding AOP and AspectJ
1. Discovering AOP
1.1. Life without AOP1.1.1. Code tangling1.1.2. Code scattering1.2. Modularizing with AOP1.3. Anatomy of an AOP language1.3.1. The AOP language specification1.3.1.1. IMPLEMENTATION OF CONCERNS1.3.1.2. WEAVING RULES SPECIFICATION1.3.2. The AOP language implementation1.4. Fundamental concepts in AOP1.5. AOP by analogy1.5.1. Cascading Style Sheets (CSS)1.5.2. Database systems1.5.2.1. SQL AND POINTCUTS1.5.2.2. TRIGGERS AND ADVICE1.5.3. Event-oriented programming1.6. Implementations of AOP1.6.1. AspectJ1.6.2. Spring AOP1.6.3. Other implementations of AOP1.7. Alternatives to AOP1.7.1. Frameworks1.7.2. Code generation1.7.3. Design patterns1.7.3.1. OBSERVER PATTERN1.7.3.2. CHAIN OF RESPONSIBILITY1.7.3.3. DECORATOR AND PROXY1.7.3.4. INTERCEPTOR1.7.4. Dynamic languages1.8. Costs and benefits of AOP1.8.1. Costs of AOP1.8.1.1. NEED FOR GREATER SKILLS1.8.1.2. COMPLEX PROGRAM FLOW1.8.2. Benefits of AOP1.8.2.1. SIMPLIFIED DESIGN1.8.2.2. CLEANER IMPLEMENTATION1.8.2.3. BETTER CODE REUSE1.9. Summary
2. Introducing AspectJ
2.1. Writing your first AspectJ program2.1.1. Setting up the example2.1.2. Adding an aspect2.2. AspectJ crosscutting construct2.2.1. Common crosscutting constructs2.2.1.1. JOIN POINT2.2.1.2. POINTCUT2.2.1.3. ASPECT2.2.2. Dynamic crosscutting construct: advice2.2.3. Static crosscutting constructs2.2.3.1. INTER-TYPE DECLARATION2.2.3.2. WEAVE-TIME DECLARATION2.3. AspectJ alternative syntax2.4. Weaving mechanisms2.4.1. Source weaving2.4.2. Binary weaving2.4.2.1. STEP 1: COMPILING THE JAVA SOURCES2.4.2.2. STEP 2: COMPILING THE ASPECT2.4.2.3. STEP 3: WEAVING THE ASPECT2.4.3. Load-time weaving2.5. AspectJ weaving: under the hood2.5.1. The compiled aspect2.5.2. The woven class2.6. Spring AspectJ integration2.7. AspectJ logistics overview2.7.1. IDE integration2.7.2. AspectJ documentation tool2.8. Summary
3. Understanding the join point model
3.1. Understanding the join point model3.1.1. Join points3.1.2. Pointcuts3.1.2.1. SELECTING JOIN POINTS3.1.2.2. COLLECTING JOIN POINT CONTEXT3.1.2.3. USING SIGNATURES3.1.2.4. USING RUNTIME SELECTION CRITERION3.1.2.5. DETERMINING POINTCUTS STATICALLY3.2. Categorizing exposed join points3.2.1. Method join points3.2.2. Constructor join points3.2.3. Field access join points3.2.4. Exception-handler join points3.2.5. Class-initialization join points3.2.6. Object initialization join points3.2.7. Object pre-initialization join points3.2.8. Advice execution join points3.3. Join point demonstration example3.3.1. The aspect3.3.2. The result3.4. Understanding pointcut basics3.4.1. Named and anonymous pointcuts3.4.1.1. REUSABILITY: NAMED POINTCUTS3.4.1.2. USE ONCE: ANONYMOUS POINTCUTS3.4.2. Pointcut operators3.5. Signature syntax3.5.1. Type signature patterns3.5.1.1. BASIC TYPE SIGNATURE PATTERN3.5.1.2. ANNOTATION-BASED TYPE SIGNATURE PATTERN3.5.1.3. GENERIC-BASED TYPE SIGNATURE PATTERNS3.5.1.4. COMBINING TYPE SIGNATURE PATTERNS3.5.2. Method and constructor signature patterns3.5.2.1. BASIC METHOD SIGNATURE PATTERN3.5.2.2. ANNOTATION-BASED METHOD SIGNATURE PATTERN3.5.2.3. CONSTRUCTOR SIGNATURE PATTERN3.5.3. Field signature patterns3.5.3.1. BASIC FIELD SIGNATURE PATTERN3.5.3.2. ANNOTATION-BASED FIELD SIGNATURE PATTERN3.6. Implementing pointcuts3.6.1. Kinded pointcuts3.6.2. Non-kinded pointcuts3.6.2.1. CONTROL-FLOW BASED POINTCUTS3.6.2.2. LEXICAL-STRUCTURE BASED POINTCUTS3.6.2.3. EXECUTION-OBJECT POINTCUTS3.6.2.4. ARGUMENT POINTCUTS3.6.2.5. ANNOTATION-BASED POINTCUTS3.6.2.6. CONDITIONAL CHECK POINTCUTS3.7. Summary
4. Modifying behavior with dynamic crosscutting
4.1. Advice overview4.1.1. Advice classification4.1.2. Advice syntax4.2. Comparing advice to methods4.2.1. Similarities between advice and methods4.2.2. Differences between advice and methods4.3. Advice in depth4.3.1. Before advice4.3.2. After advice4.3.2.1. AFTER (FINALLY)4.3.2.2. AFTER RETURNING4.3.2.3. AFTER THROWING4.3.3. Around advice4.3.3.1. PROCEEDING WITH ADVISED JOIN POINT4.3.3.2. RETURNING A VALUE FROM AROUND ADVICE4.3.3.3. THROWING AN EXCEPTION FROM AROUND ADVICE4.3.3.4. EXAMPLE: IMPLEMENTING FAULT TOLERANCE4.4. Collecting join point context4.4.1. Collecting objects at the join point4.4.2. Implementing simple caching4.5. Accessing join point context via reflection4.5.1. The reflection API4.5.1.1. THE ORG.ASPECTJ.LANG.JOINPOINT INTERFACE4.5.1.2. THE ORG.ASPECTJ.LANG.JOINPOINT.STATICPART INTERFACE4.5.2. Improving caching using reflection APIs4.5.3. Comparing the reflection API to pointcuts4.6. Summary
5. Modifying structure with static crosscutting
5.1. Introducing members5.1.1. Scattering and tangling5.1.2. Untangling with aspects5.1.3. Mixing with mixins5.1.4. Member introduction rules5.1.5. Idiom: Providing a default interface implementation5.2. Modifying the type hierarchy5.3. Introducing members to multiple types5.4. Supplying annotations5.5. Declaring weave-time errors and warnings5.6. Softening checked exceptions5.7. Summary
6. Aspects: putting it all together
6.1. Working with aspects6.1.1. Similarities between aspects and classes6.1.1.1. ASPECTS CAN INCLUDE DATA MEMBERS AND METHODS6.1.1.2. ASPECTS CAN HAVE ACCESS SPECIFICATIONS6.1.1.3. ASPECTS CAN BE ABSTRACT6.1.1.4. ASPECTS CAN EXTEND CLASSES AND ABSTRACT ASPECTS, AS WELL AS IMPLEMENT INTERFACES6.1.1.5. ASPECTS CAN BE EMBEDDED IN CLASSES AND INTERFACES AS NESTED ASPECTS6.1.2. Differences between aspects and classes6.1.2.1. ASPECTS CAN'T BE DIRECTLY INSTANTIATED6.1.2.2. ASPECTS CAN'T INHERIT FROM CONCRETE ASPECTS6.1.2.3. CONCRETE ASPECTS MAY NOT DECLARE GENERIC PARAMETERS6.1.2.4. ASPECTS CAN BE MARKED AS PRIVILEGED6.2. Aspect association6.2.1. Default singleton association6.2.2. Per-object association6.2.3. Per-control-flow association6.2.4. Per-type association6.2.5. Implicit limiting of join points with aspect associations6.2.6. Accessing aspect instances6.2.7. Comparing per-object association and member introduction6.2.8. Improving the caching aspect6.2.8.1. USING DEPENDENCY INJECTION WITH ASPECTS6.2.8.2. UPDATING THE PROGRAM TO CHECK CACHE BEHAVIOR6.2.8.3. WRITING AN AUTOMATED TEST FOR CACHING6.3. Aspect precedence6.3.1. Ordering of advice6.3.2. Explicit aspect precedence6.3.2.1. USING PRECEDENCE TO CONTROL ORDERING6.3.2.2. TYPICAL PRECEDENCE CONTROL PATTERNS6.3.3. Ordering advice in a single aspect6.4. Privileged aspects6.5. Summary
7. Diving into the @AspectJ syntax
7.1. Syntax overview7.1.1. Natural mapping7.1.2. Java compatibility7.1.3. Early error detection7.2. Mapping aspects7.2.1. Specifying aspect association7.2.2. Accessing the aspect instance7.2.3. Declaring aspect precedence7.3. Mapping pointcuts7.3.1. Mapping abstract pointcuts7.3.2. Mapping concrete pointcuts7.3.2.1. REQUIREMENTS FOR POINTCUT EXPRESSIONS7.3.2.2. REQUIREMENTS FOR COMPILATION7.3.2.3. SPECIAL TREATMENT OF THE IF() POINTCUT7.4. Mapping dynamic crosscutting constructs7.4.1. The before advice7.4.1.1. ADVISING WITH ANONYMOUS POINTCUTS7.4.1.2. ADVISING WITH NAMED POINTCUTS7.4.1.3. USING A REFLECTIVE JOIN POINT CONTEXT7.4.1.4. USING A TYPED JOIN POINT CONTEXT7.4.2. The after advice7.4.2.1. EXPRESSING AFTER RETURNING AND AFTER THROWING7.4.2.2. COLLECTING THE RETURN VALUE AND THROWN EXCEPTION7.4.3. The around advice7.4.3.1. PROCEEDING WITH THE ORIGINAL JOIN POINT EXECUTION7.4.3.2. ALTERING THE JOIN POINT CONTEXT7.5. Mapping static crosscutting7.5.1. Mapping weave-time declarations7.5.2. Mapping declare parents7.5.2.1. DECLARING PARENTS FOR MARKER INTERFACES7.5.2.2. DECLARING PARENTS FOR NON-MARKER INTERFACES7.5.2.3. UTILIZING THE INTRODUCED TYPE7.6. Features not implemented in @AspectJ7.6.1. Associating annotations7.6.2. Introducing data and methods7.6.3. Softening exceptions7.6.4. Privileged aspects7.7. Comparing syntax styles7.8. Summary
8. AspectJ weaving models
8.1. Classifying weaving models8.2. Build-time weaving8.2.1. Build-time source code weaving8.2.2. Build-time binary weaving8.3. Load-time weaving8.3.1. Load-time weaving overview8.3.2. Configuring the load-time weaver8.3.2.1. SPECIFYING ASPECTS TO BE WOVEN8.3.2.2. DEFINING CONCRETE ASPECTS8.3.2.3. DEFINING ASPECT PRECEDENCE8.3.2.4. SPECIFYING WEAVING OPTIONS IN AOP.XML8.3.2.5. USING MULTIPLE AOP.XML FILES8.4. Load-time weaver in action8.5. Choosing syntax and weaving8.6. Summary
9. Integration with Spring
9.1. Spring AOP fundamentals9.1.1. Setting up the application9.1.2. Utilizing the @AspectJ syntax9.1.3. Spring IDE9.2. Spring AOP under the hood9.2.1. A quick introduction to dynamic proxies9.2.2. Proxy-based AOP with Spring9.2.3. Spring AOP internals9.2.4. Proxy-based AOP in DI framework9.2.5. Limitations of Spring AOP9.2.5.1. METHOD EXECUTION-ONLY JOIN POINTS9.2.5.2. BEAN-ONLY CROSSCUTTING9.2.5.3. EXTERNAL CALL-ONLY INTERCEPTION9.3. @AspectJ support in depth9.3.1. Dynamic crosscutting9.3.1.1. POINTCUTS9.3.1.2. SELECTING SPRING BEANS9.3.1.3. ADVICE9.3.1.4. ASPECT ORDERING9.3.1.5. ASPECT INSTANTIATION MODELS9.3.2. Static crosscutting9.4. Schema-style AOP support9.4.1. Mapping aspects9.4.2. Mapping pointcuts9.4.3. Mapping advice9.4.4. Mapping static crosscutting9.5. Tapping into the full power of AspectJ9.5.1. Configuring aspects using Spring DI9.5.2. Spring-driven LTW9.5.2.1. SPRING-DRIVEN LTW IN ACTION9.5.2.2. SPRING-DRIVEN LTW: UNDER THE HOOD9.6. Choosing an appropriate AOP system9.6.1. Comparing AspectJ to Spring AOP9.6.2. Comparing Spring AOP syntax9.6.3. It's decision time9.7. Summary
2. Applications of AspectJ with Spring
10. Monitoring techniques
10.1. Tracing in action10.1.1. Tracing the aspect-oriented way10.1.2. Tracing the conventional way10.2. Conventional vs. AOP tracing10.3. Selecting join points of interest10.3.1. Selection based on static structure10.3.1.1. LEVERAGING PACKAGE STRUCTURE10.3.1.2. LEVERAGING TYPE STRUCTURE10.3.1.3. LEVERAGING ANNOTATIONS10.3.1.4. LEVERAGING METHOD SIGNATURE10.3.2. Selection based on dynamic context10.4. Tracing10.4.1. Indenting trace calls10.4.2. Sharing tracing aspect functionality10.4.3. Tracing intra-method activities10.4.4. Logging the method parameters10.4.5. Choosing a type-specific logger10.5. A detour: deployment options for monitoring aspects10.5.1. Utilizing load-time weaving10.5.2. Utilizing Spring AOP for tracing10.6. Exception monitoring10.7. Improving conventional logging10.7.1. Modularizing NDC with conventional logging10.7.2. Modularizing MDC with conventional logging10.8. Performance monitoring10.9. Runtime control of monitoring aspects10.10. Summary
11. Policy enforcement: keeping your design intact
11.1. AOP-based policy enforcement overview11.2. Policy origins and destinations11.3. Enforcement using AOP11.3.1. Compile-time enforcement11.3.2. Runtime enforcement11.4. Comparison with code-analysis tools11.5. Implementing flexible access control11.5.1. Restricting exposure11.5.2. Limiting collaboration11.5.3. Enforcing the factory pattern11.6. Enforcement idiom: return-value restriction11.7. Enforcing JPA-JDBC integration policies11.8. Implementing EJB policies11.8.1. Developing a core EJB enforcement aspect11.8.2. Defining EJB pointcuts11.8.3. Dealing with XML-based EJBs11.8.4. Implementing a "no EJBs" policy11.9. Detecting Swing concurrency control policy violations11.9.1. Understanding the problem11.9.2. Detecting the violation11.10. Summary
12. Learning design patterns
12.1. The worker object pattern12.1.1. The current solution12.1.2. An overview of the worker object pattern12.1.3. The worker object pattern template12.1.4. Getting the return value12.1.5. A summary of the worker object pattern12.2. The wormhole pattern12.2.1. The current solution12.2.2. An overview of the wormhole pattern12.2.3. The wormhole pattern template12.2.4. A summary of the wormhole pattern12.3. The participant pattern12.3.1. Current solutions12.3.1.1. TAKE ONE12.3.1.2. TAKE TWO12.3.2. An overview of the participant pattern12.3.3. The participant pattern template12.3.3.1. SCOPING PARTICIPATION12.3.3.2. AUGMENTING BEHAVIORAL PARTICIPATION12.3.4. Consequences of the participant pattern12.3.5. A summary of the participant pattern12.4. Annotation-driven participant pattern12.4.1. Current solution12.4.2. The annotation-driven participant pattern template12.4.3. Annotation type abstraction12.4.3.1. FUNCTIONALITY-SPECIFIC ANNOTATION12.4.3.2. SUBJECTIVE CHARACTERISTIC-BASED ANNOTATION12.4.3.3. OBJECTIVE CHARACTERISTIC-BASED ANNOTATION12.4.4. Variation: bridged participation pattern12.4.5. Role of ADPP in library aspects12.5. Summary
13. Implementing concurrency control
13.1. Modularizing Swing's single-thread rule13.1.1. A test problem13.1.2. Solution: the conventional way13.1.3. Solution: the AspectJ way13.1.3.1. THE FIRST VERSION13.1.3.2. THE SECOND VERSION13.1.3.3. THE THIRD VERSION13.1.4. Improving the solution13.1.4.1. DEALING WITH EXCEPTIONS13.1.4.2. AVOIDING THE OVERHEAD13.2. Improving the responsiveness of UI applications13.3. Modularizing the read-write lock pattern13.3.1. Implementation: the conventional way13.3.2. Implementation: the AspectJ way13.3.2.1. IMPLEMENTING THE BASE ASPECT13.3.2.2. IMPLEMENTING SUBASPECTS13.4. Summary
14. Managing transactions
14.1. Transaction management implementations14.1.1. Conventional implementation14.1.2. AOP implementation14.2. Transaction-management players14.2.1. Transaction management in architecture14.2.2. Transaction management: one concept, too many implementations14.2.3. Transaction-management abstraction14.3. Aspect implementation choices14.3.1. Proxy-based AOP14.3.2. Byte-code weaving14.4. Transaction-management aspect (almost) from scratch14.4.1. Implementing the aspect14.4.2. Testing the aspect14.4.3. Road test for the aspect14.4.3.1. ASPECTJ BYTE-CODE WEAVING14.4.3.2. SPRING'S PROXY-BASED AOP14.5. Spring's transaction management14.5.1. XML-driven transaction management14.5.2. Annotation-driven transaction management14.5.3. AspectJ weaver-based transaction management14.6. Implementing fault tolerance for transactional operations14.6.1. Base aspect14.6.2. Using the annotation-driven participant pattern14.6.3. Configuring the aspect14.6.4. Testing the fault-tolerance aspect14.6.5. Improving the solution14.6.5.1. DEALING WITH NONTRANSACTIONAL RESOURCES14.6.5.2. PORTING TO SPRING AOP14.7. Summary
15. Securing applications
15.1. Securing applications with conventional techniques15.1.1. The do-it-yourself approach15.1.2. The framework-based approach15.2. Modularizing security using AOP15.3. A quick overview of Spring Security15.3.1. Authentication15.3.2. Authorization15.4. Implementing a security solution from scratch15.4.1. Implementing authentication aspects15.4.1.1. BASE AUTHENTICATION ASPECT15.4.1.2. EXAMPLE SUBASPECT15.4.2. Implementing authorization aspects15.4.2.1. BASE ASPECT15.4.2.2. SUBASPECT WITHOUT ANNOTATIONS15.4.2.3. ANNOTATION-DRIVEN SUBASPECT15.5. Implementing field-level authorization15.6. Spring Security prebuilt solutions15.6.1. Web security15.6.2. Service level security15.6.2.1. EXTERNAL CONFIGURATION OPTION15.6.2.2. ANNOTATION-BASED OPTION15.6.2.3. GOING BEYOND ROLES15.6.3. Domain-object security15.7. Additional ideas in implementing security15.7.1. Auditing access15.7.2. Filtering field content15.8. Summary
16. Improving domain logic
16.1. Empowering objects16.1.1. Enabling rich behavior16.1.2. Injecting dependencies with Spring and AspectJ16.1.2.1. ANNOTATION-BASED DI16.1.2.2. DOMAIN INTERFACES-BASED DI16.1.3. Possibilities enabled by domain-object DI16.1.3.1. ENRICHING DOMAIN OBJECT BEHAVIOR16.1.3.2. DISCUSSION: RETHINKING THE SERVICE LAYER16.1.3.3. SIMPLIFYING THE DOMAIN OBJECT API16.2. Implementing business logic16.2.1. Improving inventory management16.2.2. Checking for the order-level constraint16.2.3. Refactoring using aspects16.3. Managing access to objects16.3.1. Applying specific policies16.3.2. Applying general policies16.4. Summary
17. Taking the next step
17.1. The adoption path: technologies17.1.1. Spring AOP17.1.2. AspectJ17.2. The adoption path: applications17.2.1. Development aspects17.2.1.1. HELPING WITH DEBUGGING17.2.1.2. MONITORING PERFORMANCE17.2.1.3. ENFORCING POLICIES17.2.1.4. HELPING WITH TESTING17.2.2. Production aspects17.2.2.1. INFRASTRUCTURE ASPECTS17.2.2.2. CROSSCUTTING DOMAIN LOGIC17.2.2.3. REFACTORING ASPECTS17.3. Applying AOP to new problems17.3.1. Talking the talk17.3.2. Walking the walk17.4. Employing AOP in development phases17.4.1. AOP in the design phase17.4.2. AOP in the implementation phase17.4.2.1. IMPLEMENTING CORE CONCERNS17.4.2.2. IMPLEMENTING CROSSCUTTING CONCERNS17.4.3. AOP in the maintenance phase17.4.4. AOP in legacy projects17.5. Parting thoughts
A. Setting up the example
A.1. Domain classesA.2. Repository layerA.3. Service layerA.4. Application configurationA.5. The web layerA.6. Logging configurationA.7. Building and running the application
B. Using Ant with AspectJ
B.1. Weaving sourcesB.2. Creating an aspect libraryB.3. Weaving into jar files
C. Using Maven with AspectJ
C.1. Weaving sourcesC.2. Creating an aspect libraryC.3. Weaving into jar files

Overview

To allow the creation of truly modular software, OOP has evolved into aspect-oriented programming. AspectJ is a mature AOP implementation for Java, now integrated with Spring.

AspectJ in Action, Second Edition is a fully updated, major revision of Ramnivas Laddad's best-selling first edition. It's a hands-on guide for Java developers. After introducing the core principles of AOP, it shows you how to create reusable solutions using AspectJ 6 and Spring 3. You'll master key features including annotation-based syntax, load-time weaver, annotation-based crosscutting, and Spring-AspectJ integration. Building on familiar technologies such as JDBC, Hibernate, JPA, Spring Security, Spring MVC, and Swing, you'll apply AOP to common problems encountered in enterprise applications.

This book requires no previous experience in AOP and AspectJ, but it assumes you're familiar with OOP, Java, and the basics of Spring.

About the Technology

About the Book

What's Inside

Totally revised Second Edition
When and how to apply AOP
Master patterns and best practices
Code you can reuse in real-world applications

About the Reader

This book requires no previous experience in AOP and AspectJ, but it assumes you're familiar with OOP, Java, and the basics of Spring.

About the Author

An expert in enterprise Java, Ramnivas Laddad is well known in the area of AOP and Spring. He is a committer on the Spring Framework project.

Quotes
Clear, concisely worded, well-organized... a pleasure to read.
- Rod Johnson, Creator of the Spring Framework

Ramnivas showcases how to get the best out of AspectJ and Spring.
- Andy Clement, AspectJ Project Lead

One of the best Java books in years.
- Andrew Rhine, eSecLending

By far the best reference for Spring AOP and AspectJ.
- Paul Benedict, Argus Health Systems

Ramnivas expertly demystifies the awesome power of aspect-oriented programming.
- Craig Walls, author of Spring in Action

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781933988054Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills