XPages: The Next Step In Your Life As A Notes Developer
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

XPages: The Next Step In Your Life As A Notes Developer

on

  • 4,684 views

Presentation given at AUSLUG 2011 comparing the differences and similarities between Notes Classic development and IBM XPages development.

Presentation given at AUSLUG 2011 comparing the differences and similarities between Notes Classic development and IBM XPages development.

Statistics

Views

Total Views
4,684
Views on SlideShare
3,634
Embed Views
1,050

Actions

Likes
1
Downloads
61
Comments
0

8 Embeds 1,050

http://www.bleedyellow.com 996
https://www.bleedyellow.com 41
http://bleedyellow.com 5
http://planetlotus.org 3
http://www.linkedin.com 2
http://web1.conversationminer.com 1
http://translate.googleusercontent.com 1
http://www.slashdocs.com 1
More...

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • G'day and welcome to today's presentation IBM XPages The Next Step in Your Life as a Notes Developer
  • But first a Warning This presentation contains absolutely NO CODE If you are a code junkie and you are here only to overdose on XPages code I'm sorry... but you'll need to look elsewhere for a FIX.
  • So lets get started.... No two Notes developers are alike We are all individuals Our ability to adapt to XPages is going to vary person by person. For the work I do at GBS I have developed personas for three broad categories of Notes developers. Let's take a quick look at Tom, Dick, and Harry three Notes developers whose approach to Notes development (and XPAGES)... is going to vary quite a bit.
  • Tom is our Typical Power User He is not a full-time developer He is a business user who has found that Notes is a very powerful tool to help him automate his job He can't wait for IT to solve his problems so he solves them himself Of course he uses Lotus Notes... He develops application for the Notes client only He typically creates Forms, Views (and occasionally) Pages and Outlines He adds business logic to his applications using Simple Actions & @Formulae On the odd occasion he feels brave and codes some in-line LotusScript The LS code is usually stolen (oops) borrowed from other apps He does not use a formal SDLC... he know what he wants and he just does it. Tom's approach is simple but very very effective His applications are never documented and when he leaves nobody knows anything about how they work Tom is the backbone of a movement that has seen Notes applications explode across his organization XPages is not going to be a good match form Tom at all At least not in the current version of Xpages available today Tom's needs are probably going to be best met by continuing to develop Notes classic applications.
  • Dick is our Traditional Notes Developer. His full-time role is to develop Notes applications. Dick was once a power user but has since taken his skills to the next level He develops a mix of Notes client and Web client applications. He writes most of his business logic using LotusScript Some (but not all) of this is now placed in LotusScript libraries. The code is procedural. He makes extensive use of the Notes event model to add logic to his applications. Dick has learnt the value of agents. These are coded using a combination of @Formula or LS. Dick has libraries of LS code he reuses in many of his apps. He has learnt the power of templates Dick is a one man Notes programming machine. He prefers to use an iterative prototyping methodology whenever he can. For larger projects his company requires him to follow a formal (waterfall) SDLC. Dick attends Lotusphere and other User group events whenever he can to take his development skills to the next level. Lately he has been hearing a lot about XPages and he is ready to take the next step. The good news is that XPages is probably going to be a good match for Dick. He has the skills to make the jump and he is motivated to learn something new and exciting.
  • Now... lets meet Harry Harry is a software engineer He has only been working with Lotus Notes for a few years He has a University degree in Computer Science and has done some programming with Java, Ruby, and C# He places almost all his LS code in libraries using OOP Harry already uses Java to write some of the business logic for his applications He is the "Go to" guy the company turns to when they need a quick solution for the Notes Client or Web client. Lately he has been getting a lot of requests to develop mobile applications Harry makes a lot of use of dojo along with a number of Open Source java projects. Dick likes to use Agile SDLCs and favours Test-Driven development Dick's company has just migrated from Notes/Domino 7 To Notes 8.5.2. This means he is now able to start to make use of Xpages for many of his projects. XPages is going to provide Harry with a lot of power and flexibility he never had before. Unlike Dick, Harry is probably going to be inclined to use Java quite extensvely when he builds applications. He is likely to be the first person in hois company to make extensive use of plug-ins, the XPages Extension Library and the IBM Social Business toolkit.
  • So let's now take a look at the architecture of Notes application development. Comparing and contrasting Notes Classic and XPages
  • Perhaps the most striking thing about the architecture of Notes is the NSF container The NSF container is an important part of what makes Notes RAD It provides a single container for both application code and data This makes it very easy and very fast to deploy onto one or more servers. The NSF is a distinctly non-SQL data store. A characteristic that has started to become fashionable in the IT world some 20 years after Notes first started doing it. The NSF also supports DAOS as a way of centralizing multiple instances of large attachments The good news is that the NSF is the same container used to deliver BOTH Notes Classic and XPages applications.
  • Alongside the NSF we have the Notes Security model. Many of the security constructs we use with Notes Classic applications such as ACLS, Roles, Server Access and Reader/Author fields remain the same. One major difference is that the concept of ECLs do not exist in a Web browser. There are also some differences in the way Server Access is implemented because much of the XPage code is now being executed on the server rather than inside the Notes Client. So there are some differences to watch out for... Note: It is possible to run XPages applications inside the Notes Client in what is known as XPiNC. The security model for XPiNC is a lot closer to the security model for Notes Classic. We will cover XPiNC in more detail a little later in the presentation.
  • Another great strength of Notes Application development has been Replication and Clustering. It is very simple to deploy multiple instances of a single application to servers around the world to reduce potential performance bottlenecks. While Replication and Clustering will continue to work the same, they will play a slightly different role in XPages applications. Especially those being accessed via a Web browser. XPiNC supports failover, but the concept is foreign to Browser-based applications. The concepts of Web farms and load balancing are not yet fully supported by XPages and care should be taken when deploying XPage applications onto multiple servers.
  • The client/server model used by XPages differs significantly from Notes classic applications. As an Xpage developer, this is where you will probably face your greatest challenges adjusting to the Xpage architecture. Notes client applications typically operate with a thick client model. Almost all of the business logic written using simple actions; @formulae; and LotusScript executes on the Notes client. With XPages, much of the code (SSJS) executes on the server. Conversations with the user must be designed differently. For example... Field validation will typically now be done on the server. So it will be better to validate all the fields at once and provide a list of issues, rather than validate fields one at a time. Whereas almost everything was previously done with LotusScript you will now find yourself having to make choices between the use of (client sided) JavaScript and SSJS. Highly interactive applications will make extensive use of Ajax, which is integrated into XPages. Because much of the business logic for you applications now runs on the server it will become necessary to remember information between interactions with the user. This involves learning about the use of Scoped variables such as Session Scope, Application Scope, and View Scope. You may also need to learn about things such as serialization, a requirement for data to be saved as scope variables.
  • As I mentioned in my introduction Lotus Notes is renowned as being a great tool for Rapid Application Development. When your employer needs an application developed quickly there is always Lotus Notes.
  • What has made Notes classic such a great RAD tool is that it is... Easy to learn & Well documented And it provides a toolkit that allows applications to be built from scratch in a fraction of time other development platforms requires. Notes applications are integrated into the Notes client that delivers a comprehensive set of capabilities that are automatically available to all Notes applications. Things such as Security.. Searching.. Integrated IM, and Offline support XPages in its current form still presents some challenges as a RAD tool It is a lot more complicated making it harder to get started with your "First App" IBM continue to have disappointed with the level and quality of documentation that is available. But there are ways to minimize this XPages is way way more powerful and way way more extensible. This means that ultimately you are going to be able to take Xpages development to levels never before possible with Notes Classic. XPages is still in the early stages of its life. Expect to see some major improvements over the next 1-2 years that will dramatically improve the RAD capabilities of the platform. IBM seem to be starting to recognize the importance of Notes as a RAD tool.. Especially in the area of developing Social Applications. This includes the availability of the Xpages Extension Library and the IBM Social Business Toolkit.
  • RAD is very dependant on the ability to reuse code... With Notes classic we had a range of features such as Shared Fields Shared Columns Subforms and Script Libraries that allow us to reuse components within the same application and across multiple applications With XPages we get a new design element known as The Custom Control I often here Custom Controls described as Subforms on Steroids. We will cover these in a little more detail later For Java developers we have the ability to build custom components Script libraries continue to be an option for (client) JavaScript and SSJS. In 8.5.3 we will also see a new Java Element being added XPages also has integrated support for CSS and Themes allowing multiple applications to be developed using a consistent look and feel.
  • One of the things that differentiates IBM from Microsoft is the support for Open Standards. Microsoft prefers to lock its customers in to a proprietary stack. In contrast, IBM are showing a preference to support open standards. This is much more evident with XPages than Notes classic With Notes classic we had a few resources such as OpenNTF that allowed Notes developers to download templates and code snippets for use in applications. With XPages we continue to see templates available on OpenNTF. We also have the ability to extend applications through the use of custom controls, components, and plug-ins. By supporting open standards we as XPage developers also have a greater capacity to go beyond the yellow bubble to share and participate in a much wider range of OpenSource projects such as the great many OpenSource Java projects that are available.
  • To many developers, Notes Classic development was synonymous with Notes client development. Yes you can also make those applications run in a Web browser, but this often required a multitude of hacks to make it work. Out of the box Notes delivered GREAT Notes client applications. With XPages the focus is more on Web development. It is possible to build XPages that run in the Notes client. This uses XPiNC which effectively runs a XULRunner browser session inside the Notes client. It does work, but I would look on it more (as it exists today) as being Xpages supporting the Notes Client with a similar level of success as which Notes Classic supported Web Browsers.
  • There are some important capabilities available when building Xpage applications for XPiNC that you should be aware of... XPiNC allows the use of standard Notes ID authentication rather than the Web browser authentication we are probably already familiar with. XPiNC will support taking an XPages application Offline. XPiNC will allow agents to be executed on the Client. This may be very important when taking applicatiosn already built with significant amounts of LotusScript code inside agents. Remember: LotusScript does not execute inside an XPage. XPiNC provides Failover capabilities should one server in a cluster become unavailable. With XPiNC Dialogs with the user make use of the Native Operating System. XPiNC also provides native support for the detection of unsaved documents prompting the user to save their changes before navigating away from the current page. For browser-based applications this logic must be added manually to the app.
  • As mentioned on the last slide... Web development is doable In Notes Classic (or Domino Web Development), but it often required a lot of hacks. We had separate WebQueryOpen and WebQuerySave agents, PassThruHTML could be added to Form/Pages HTML tags could be added to View Columns JavaScript caould be added to some events It usually possible to get the job done but the code was often difficult to maintain. It was a software engineers nightmare... With XPages, development for Web clients is standard. The XPage platform is designed to deliver modern Web 2.0 applications.
  • OK... Let's now take a look at the Data Access layer When we think of Notes Applications we rarely think of them as having a Data Access layer... The data is just there
  • In Notes Classic our database contains a loose collection of documents. Each document is typically associated with a Form that is used to view/maintain data in that document. Somehow Notes magically puts all the data there. With XPages we are introduced to the concept of DataSources One of the available Data Sources is the NotesForm The NotesForm allows us to associate data in a Notes document with controls on an XPage We can use Forms from existing applications or build new Forms from Scratch. In the XPages realm the only thing important about a form is providing a list of fields. Any formatting and business logic added to the form is largely ignored.
  • Typically Notes applications make extensive use of Views and Folders. For Views, selection formula defines those documents that are to be included. Columns are added to views to define the data that is to be available for each row (or document) With Notes Classic data definitions are combined with the presentation characteristics. Each view is only able to be presented the one way. In Xpages we have the NotesView datasource which can be used to display the contents of views on anXPages The same view can be used on multiple Xpages, with each Xpage able to present the data in different ways. Additional columns can be added to a view, including the ability to join data together from multiple documents. A capability that has long been the holy grail for many Notes classic developers. The Repeat Control in Xpages also privides some very interesting capabilities for looping over the contents of a view/folder to display data in a number of ways never before possible. And the possibilities don't end there.... In Notes Classic a form is typically bound to a single document and a view displays... well the view With XPages it is possible to include data from multiple sources. This includes displaying multiple documents and or views on a single XPage. We are also not constrained to working with data from the NSF container. t is also posisble to bind data to XML sources and even other Relational database. In the future it will be this capability that takes Notes development into a whole new frontier of opportunities.
  • Next we will review the Presentation Layer This is where the rubber meets the road in a Notes application
  • Notes Classic has a comprehensive range of design elements and controls which can be used to display the data inside an NSF to the user. For Xpages Forms and Pages are replaced by a single design element - The XPage We have a much broader range of controls that can be added to An XPage We have a range of container controls such as Divs There are a wide range of input controls to display and capture data The Repeat Control provides a powerful way to repeat information without the need to resort to the treasured Notes Classic technique of Field_1, Field_2 etc along with suitable to Hide-When formulae to display just those rows with data. The concept of Hide-When formulae is replaced by the Rendered property. Instead of when not to display something we now use tyhe much more intuitive When to display something logic. Form properties typically have static values in Notes Classic. In XPages we have the blue diamond that allows most properties to have their values computed.
  • The concept of Subforms in Notes Classic is replaced by Custom Controls Custom Controls are way more powerful than Subforms allowing the developer to do things such as.. Using the same field in multiple locations The same custom control can be used multiple times within the same XPage. For example within a Repeat Control Custom Controls support properties allowing data to be passed from the parent to the custom control. Trust me... As an Xpage developer You are going to love Custom Controls.
  • As you would expect in any modern Web development platform XPages have integrated support for both CSS and Themes. While CSS had limited support in Notes Classic XPages allow almost all visual components to be linked to CSS classes. Classes can be computed using business logic to dynamically change the look of an application based upon conditions at runtime. Themes build on CSS by allowing browser specific needs to be taken into account. Themes are also a way to make an application look different on different devices.
  • I would like to draw you attention to one specific CSS Framework. OneUI.... This is a set of Styles/Themes developed by IBM. It is not a requirement that you adopt OneUI in your own applications. But it is important to know that it is there and that this represents the look & feel that IBM is using within their own products. This includes the Notes Mail template, the new TeamRoom template, Lotus Connections LotusLive etc. Future versions of OneUI will also incorporate many of the design ideas developed as part of project Vulcan.
  • HTML is always an important part of any Web application. With Domino Web Development it was almost always necessary to intervene and inject your own HTML into the application in order to make the application look good. or even to behave correctly. With XPages it is possible in many situations to completely forget about HTML. The controls provided by XPages simply take care of that entire layer of complexity. XPages provides a default render kit that generates the necessary HTML for most modern browsers. But like a lot of things with XPages... If you don't like the way it does things you have the option of doing things yourself. The XPage event model support beforeRender and afterrender events that allow you to add additional logic just before or just after the HTML has been generated. In addition it is possible to build your own render kits that render controls in a completely different way. One example of this we are exploring at GBS is the ability to automatically render an application on a mobile device in a completely different way to a standard browser. Not by changing the presentation layer in the XPage but by developing separate render kits that control how each component is rendered on each device.
  • Moving along... Lets now take a look at how we represent our Business logic inside a Notes application
  • Notes Classic provides 14 Simple Actions which can be used as a quick way of performing common tasks With XPages we have 12 server and 3 client based simple actions. With XPages however you also have the ability to define your own simple actions.
  • Notes Classic provides us with a portfolio of 300 @Functions and 391 @Commands. This forms the cornerstone for the way in which many people like to add logic to their applications. With XPages IBM have extended SSJS with the implementation of 96 @Functions. Most of those are the same as the most commonly used @Functions We all know and love in Notes Classic such as @DbColumn and @Dblookup. There are also some new @Functions It is important to note that even where the same name has been used not all the @Formula available in SSJS behave exactly the same way as the originals. XPages being XPages it is possible to define your own @Formulae and even to change the behavior of IBM's implementation of @Formulae.
  • Since Notes 4, LotusScript has dominated to become the language of choice for most Notes developers. In the main the business logic implemented using LotusScript Code will now be implemented using SSJS. This is where much of the “pain” of learning XPages will be felt. SSJS is a new language based upon JS that needs to be mastered. There are many similarities and an equal number of differences. If you already know JS you have a GREAT start. An XPage Application can continue to use LotusScript code to support Agents and Web Services. XPages also supports another scripting language known as Expression Language. To find out more about EL you may need to refer to Text Books or Documentation on JSF as there is little documentation for EL within XPages.
  • Client Sided scripting is largely the domain of JavaScript. This is pretty much the case for all Web browser based applications. If you haven't already mastered JS the good news is that there are large number of books and on-line material available to get started. And remember, in learning JS you are acquiring a skillset that can be used in almost any Web development platform.
  • There are many JS frameworks available such as JQuery, YUI, Ext.ND, Prototype, and Dojo. Like any framework, they reduce the amount of code required to perform a task by implementing a set of common tasks in a callable library. As an XPage developer you are free to choose any JavaScript framework. You will probably need at least one to implement any form of sophisticated client-sided logic. Keep in mind that Dojo is integrated into XPages and forms the basis for many of the controls. If you don't have a compelling case to use something else, I would suggest at least starting with dojo. Dojo has a comprehensive library of tools that include Input Controls, charting, image previews, data grids, AJAX support, and even controls for mobile devices.
  • For heavy duty programming there is Java. Java has been available within Lotus Notes Since Notes R5 but its use has never really taken off. To fully harness the power of XPages you are going to need to develop Java skills. This is unlikely to be a requirement to get started with XPages but you should For Software Engineering this is far and away the best option for implementing OOP concepts such as Classes, Interfaces, Delegates, Event Listeners etc. If you work as part of a large Notes development team you may want to consider adding a Java expert to your team to cross-train your Notes Classic developers.
  • Almost all Notes Developers will be familiar with the Notes Document Object Model (DOM). Whether you program in LotusScript, Java, or COM, the DOM provides a way to access the content of Notes databases. Many, but not all, of the same classes such as NotesDatabase, NotesView, and NotesDocument continue to be available from SSJS. SSJS also supports a number of new classes such as the NotesXSPDocument and NotesXSPViewEntry to access XPage specific information.
  • The Event Model changes dramatically between Notes, Domino Web Development, and XPages. Each XPage has its own set of events that operate based upon the lofecycle of the actual XPage. Xpages supports multiple datasources so, in addition, each NotesForm DataSource will have a set of events such as queryNewDocument queryOpenDocument postSaveDocument Likewise every NotesView Datasource wull have a set of events such as queryOpenView postOpenView
  • Finally, lets take a quick look at some of the tools we will be using or have option of using to assist us develop our first few Xpage applications.
  • Domino Designer for Eclipse is used to develop both Notes Classic and XPage applications. The XPage editors are all Eclipse components, so DDE is actually a better fit for DDE than Notes Classic Design Elements. Much of the wasted screen real-estate that exists when editing Notes Classic applications will contain useful information when editing XPage design elements. With DDE 8.5.3 you are likely to see separate perspectives provided for Not Classic or Xpages. You will get productivity gains from the Source Code view and the drag/drop capabilities for controls. The biggest drawback of DDE is likely to be the lack of a debugger fro SSJS and XPages in general.
  • Notes Classic does not provide any integrated SCM. It was however possible to use a 3 rd parth tool such as TeamStudio CIAO to add SCM to Notes Applications. XPages still does not provide SCM. As part of the Eclipse framework it does however provide much better integration for SCM tools that support Eclipse. This includes Sunversion (SVN) and GIT. Products such as Rally can be used to integrate Code Management with Task Management and Time Management.
  • There is a growing list of resources available to learn more about XPages. Some of my favorites include:- The Mastering XPages book written by the developers of XPages inside IBM. The Notes In 9 Series of FREE videos produced by David Leedy. The XPages Cheat Sheet also developed by David Leedy. OpenNTF.Org is a great place to download examples of XPage applications. Being OpenSource you are free to explore the code to learn how these applications have been built. Plus there is a wide range range of online training material developed by TLCC.
  • And just before closing. Let me also make mention of specific topics you should make a note of to learn and master if you want to truly get the most out of Xpages. JSF – The Java-based technology on which Xpages is built. Eclipse – The development platform used for DDE and the Notes Standard client. Dojo – The JS framework used extensivley by Xpages JavaScript. Client sided scripting. And while SSJS is not JS, it is based upon JS so many of the material written for JS will also be relevant to learning and mastering SSJS Java... As I have mention several times. Java is not a requirement to get started with Xpages, but a good working knowledge will allow you to extend Xpages to exciting new levels.

XPages: The Next Step In Your Life As A Notes Developer Presentation Transcript

  • 1. IBM XPages The Next Step in Your Life As a Notes Developer Peter Presnell (GBS) Paul Calhoun (GBS)
  • 2. Peter Presnell
  • 3. Paul Calhoun
  • 4. The Generic Pronoun Y'all (yaaaaawl)
  • 5. WARNING The following presentation contains absolutely NO CODE!!!!
  • 6. I'm A Notes Programmer
  • 7. The Power User
    • Clients: Notes Only
    • 8. Forms, Views, Pages, Outlines
    • 9. Simple Actions, @Formulae
    • 10. LotusScript: In-Line
    • 11. SDLC: None
  • 12. The Traditional Notes Developer
    • Clients: Notes, Web (80/20)
    • 13. LotusScript: Libraries (Procedural)
    • 14. Event Programming
    • 15. Templates
    • 16. SDLC: Iterative Prototyping or Waterfall
  • 17. The Software Engineer
    • Clients: Notes, Web, Mobile Client
    • 18. LotusScript: Libraries (OOP)
    • 19. Java & JavaScript Frameworks
    • 20. Web Services & SOA
    • 21. SDLC: Agile & Test Driven Development
    • 22. OpenSource
  • 23. Architecture
  • 24. NSF Container
    • Rapid Application Deployment
    • 25. Integrated Code/Data
    • 26. Non-SQL
    • 27. DAOS
  • 28. Security
    • ACLs
    • 29. Roles
    • 30. ECLs
    • 31. Server Access
    • 32. Reader/Author Fields
    • ACLs
    • 33. Roles
    • 34. ECLs (XPiNC)
    • 35. Server Access*
    • 36. Reader/Author Fields
  • 37. Replication & Clustering
    • Scheduled
    • 38. Clustered
    • 39. Failover
    • Load Balancing
  • 40. Client/Server Model
    • Client Based (RPC)
    • 41. Client Validation
    • 42. UI Dialogs
    Server Based (JSF)
    • Server Validation
    • 43. JavaScript V SSJS
    • 44. AJAX Support
    • 45. Scope
  • 46. R apid A pplication D evelopment
  • 47. As A RAD Tool
    • Easy To Learn
    • 48. Well Documented
    • 49. Quick To Develop
    • 50. Proprietary Thick Client
    • Complicated
    • 51. Poorly Documented
    • 52. Powerful
    • 53. Extensible
    • 54. Open Standards
  • 55. Shared Code
    • Shared Fields
    • 56. Shared Columns
    • 57. Subforms
    • 58. Libraries (LS)
    • Custom Controls
    • 59. Components
    • 60. Beans
    • 61. Libraries (JS/SSJS/Java)
    • 62. Style Sheets/Themes
  • 63. OpenSource
    • Templates
    • 64. Code Snippets
    • Templates
    • 65. Custom Controls
    • 66. Components
    • 67. Plug-Ins
    • 68. Java Libraries
  • 69. Notes Client Development
    • Standard
    • XPiNC
  • 70. XPiNC
    • Notes ID Authentication
    • 71. Offline Replication
    • 72. Client Agent Execution
    • 73. Failover Support
    • 74. Native Platform Dialogs
    • 75. Detects Unsaved Changes
  • 76. Web Client Development
    • WebQuery Agents
    • 77. PassThru HTML
    • 78. In-Line HTML
    • 79. Hacks, hacks, hacks
    • 80. Browser Plug-In (TBA)
    • Standard
  • 81. Byzantine “of, relating to, or characterized by a devious and usually surreptitious manner of operation”
  • 82. Data Access Layer
  • 83. Forms
    • Document = Form
    • NotesForm D/S
  • 84. Views/Folders
    • Selection Formula
    • 85. Columns
    • 86. Data/Presentation
    • NotesView D/S
    • 87. Add Columns
    • 88. Repeat Control
    • 89. SQL Data Sources
  • 90. Presentation Layer
  • 91. Forms/Pages
    • Forms
    • 92. Pages
    • 93. Fields
    • 94. Tables
    • 95. Layers
    • 96. Hide-When
    • 97. Static Properties
    • XPages
    • 98. Data Source
    • 99. Container Controls
    • 100. Input Controls
    • 101. Repeat Controls
    • 102. Rendered
    • 103. Computed Properties
  • 104. Subforms To Custom Controls
    • Fields Unique
    • 105. Single Instance
    • Duplicate Fields
    • 106. Multiple Instances
    • 107. Properties
  • 108. Themes & CSS
    • Limited CSS Support
    • Integrated CSS
    • 109. Themes
  • 110. OneUI
  • 111. HTML
    • Passthru HTML
    • 112. WebQueryOpen
    • Native Support
    • 113. Render Kits
  • 114. Real Programmers
  • 115. Business Logic
  • 116. Simple Actions
    • 14 Simple Actions
    • 12 Server
    • 117. 3 Client
    • 118. Build Your with EL
  • 119. @Functions
    • View Selection
    • 120. Inline @Formulae
      • 300 @Functions
      • 121. 391 @Commands
    • Agents
    • View Selection
    • 122. Inline SSJS
      • 96 @Functions
    • Agents
  • 123. Scripting Languages
    • LotusScript
      • InLine/Events
      • 124. Libraries
      • 125. Agents
      • 126. Web Services
    • SSJS
      • Inline/Events
      • 127. Computed Properties
      • 128. Libraries
    • LotusScript
      • Agents
      • 129. Web Services
    • Expression Language
  • 130. Client Scripting
    • JavaScript
      • InLine/Events
      • 131. Libraries
    • JavaScript
      • InLine/Events
      • 132. Libraries
      • 133. Dojo Libraries
  • 134. Dojo
  • 135. Programming Languages
    • Java
      • Agents
    • Java
      • Agents
      • 136. Inline/Events
      • 137. Managed Beans
      • 138. Plug-Ins
      • 139. Java Element (8.5.3)
  • 140. Document Object Model (DOM)
    • 92 Classes
    • 141. 1,800 prop/methods
    • 50 Notes Classes
    • 142. 6 new XSP Classes
  • 143. The Event Model
    • Notes Client
      • QueryOpen
      • 144. QueryRecalc
      • 145. QueryModeChange
      • 146. PostSave
    • Web Client
      • WebQueryOpen
      • 147. WebQuerySave
    • Std. XPage Events
      • beforePageLoad
      • 148. afterPageLoad
      • 149. afterRestoreView
      • 150. beforeRenderResponse
      • 151. AfterRenderResponse
    • Phase Listeners
  • 152. Tools
  • 153. DDE
    • Visual Editor
    • 154. LS Debugger
    • Source Code View
    • 155. Drag/Drop
    • 156. Limited Debugging
  • 157. Source Control
  • 158.  
  • 159. Resources
  • 160. Study Guide
    • Java Server Faces (JSF)
    • 161. Eclipse
    • 162. Dojo
    • 163. JavaScript
    • 164. Java
  • 165. Questions???