NetBeansCertifiedEngineerExpectations

Expected Outcomes, Potential Demos, and Suggested Homework for the NetBeans Platform Certified Training

Below is a list of all the sessions in the NetBeans Platform Certified Training course. In each case, the core principles that should be taught in the session are listed.

Different levels of importance in each session:

  • Know: P1 Student should be able to explain easily.
  • Be familiar with: P2 Student should have a general idea.
  • Have heard about: P3 Student might have forgotten, but was told about it.

Presentation: Introduction to the NetBeans Platform

  • Know the structure of the course
  • Know the difference between NetBeans certified associate/engineer/contributor
  • Know that students are expected to deliver projects to be certified as engineers/contributors
  • Know the location of the NetBeans Platform Certified website
  • Know the dedicated e-mail address for the course
  • Be familiar with the history of the NetBeans Platform
  • Be familiar with a variety of applications on top of the NetBeans Platform

Presentation: Getting Started with the NetBeans Platform

  • Know where the wizards are for creating new NetBeans modules.
  • Know the difference between a module and an application.
  • Know that "module".equals("plugin")
  • Know that the file-level wizards generate NetBeans API stubs
  • Know that NetBeans IDE is not essential for the NetBeans Platform
  • Be familiar with two or three file-level wizards
  • Be familiar with the general module development process
  • Have heard about the NetBeans Platform Manager
  • Have heard about the Project Properties dialog box
  • Have heard about different ways of distributing modules
  • Have been introduced to every part of the NetBeans module development ui in the IDE

Potential Demos/Homework for Presentation (one or more of these)

  • Create a new application, run it, add a new Action, run the app, then add a TopComponent, run it again.
  • Be careful to not say too much about TopComponents: there is a whole session about them later.
  • Port the Anagram Game to a TopComponent.
  • Google Toolbar.
  • Add Google Toolbar to the application.

Presentation: Dependency and Injection in Modular Systems

  • Know the value proposition of modules within an application.
  • Know the requirements for something to be a NetBeans module.
  • Know how to create a NetBeans module.
  • Know the main properties of a NetBeans module.
  • Know the basic concepts of the Lookup API.
  • Be familiar with the ServiceLoader and how it related to the Lookup API.
  • Have heard about some of the advanced Lookup topics.
  • Have heard about TopManager.

Potential Demos/Homework for Presentation (one or more of these)

  • Create a new module. Then show the students what is in the manifest.mf. Then build the module and show the students the NBM. Then open the NBM via some Zip tool and show what is inside of it. Then install the NBM, i.e., demonstrate the Plugin Manager. Then show what's happened to the content of the NBM, i.e., show the user directory and what the Plugin Manager has done with the content of the NBM.
  • Lookup demo: Create a module, within that module create a service provider interface. (Make it simple, just expose a string.) Create another module that will be the service provider, set a dependency on the first module and then implement the interface. Publish the implementation via META-INF/services. Then create a third module and use Lookup to load the service and call the method on the provider.
  • Show how you can use the layer file instead of META-INF/services.
  • Show how you can use Lookups.forPath() and then use any folder in the layer.
  • Show how JDK 6 ServiceLoader is used and then show how Lookup has a listener and why that is good.

Presentation: System FileSystem

  • Know the difference between installation dir and user dir. (And how to find user dir.)
  • Know the difference between java.io.File and FileObjects.
  • Know the special features that FileObjects have that java.io.File doesn't.
  • Know what "System FileSystem" means.
  • Know the connection between NetBeans APIs and the System FileSystem (i.e., each API determines the structure of the related layer entries).
  • Know how FileObjects relate to the System FileSystem.
  • Know how layer.xml files relate to the System FileSystem.
  • Know how to delete items from the layer.xml, how to move items around, how to localize (all via the ui!)
  • Know how layer.xml files are created (via the New File wizard's templates).
  • Know that you can browse all the layer.xml files provided by all the modules in an application via NetBeans IDE.
  • Know that they can delete the layer.xml file if they are not using it, but must also remove reference from manifest file.

Potential Demos/Homework for Presentation (one or more of these)

  • Show the "config" folder in the userdir and talk about what you see there and why those folders are there and etc.
  • Show how a layer.xml file is created.
  • Show how new entries are added to it automatically by various wizards (e.g., New Action wizard).
  • Show the ui for contrasting between the local layer.xml file and all the layer.xml files in the application.
  • Show the most commonly used layer folders (Actions, Menu, Toolbar, etc) and talk about how they relate to their related API.
  • Show how you can browse all the layer entries provided by all the modules in NetBeans IDE.
  • Show how you can hide a whole menu, then show the generated _hidden element in the layer.xml file.
  • Show how you can localize a menu item, then show the new entry in the Bundle file.
  • Show how you can take a menu item and put it in a different position, then show the generated Position tag in the layer.xml file.
  • Show that you can learn from other layer.xml files, i.e., how you can look at the required layer structure for various features in the IDE.
  • Show that you can open the layer.xml file in a different module and copy info from there into your own module's layer.xml file.

Notes on presenting the System FileSystem, by Tim Boudreau

I usually teach this by starting out describing a Filesystem as a virtual namespace for resources - things that walk and talk like files. Introduce local filesystems which really work over files on this, then point out that I can also drill through a JAR and treat things in a JAR like files on disk even though they are not - so people get that it really is virtual.Then mention that whenever someone creates some interface for accessing resources, someone is bound to write an implementation that takes multiple other instances of that interface and serves them as if they were one - it's just one of those irresistible engineery things. With that introduce MultiFileSystem as a FileSystem that takes a bunch of other FileSystem and merges them. Then introduce XMLFileSystem; then put it all together with the System Filesystem. Don't forget to mention that the reason the SFS is read-write is that the top (or bottom, depends how you look at it - I usually say "top" - the important thing is to be consistent) layer is a filesystem over a real directory on disk, the userdir. Then start up the platform, and delete the help menu. Open up the system filesystem in a shell or windows explorer and show the Help_hidden file. Manually type echo > View_hidden in the shell and restart the platform and note the view menu is gone. Then delete both and restart and show that they are back. Then point out that folders and files can fire changes, something that java.io.File can't do, and that that is how menu items appear when modules are installed and so forth.

Presentation: Nodes and Explorer Views (a.k.a. NetBeans JavaBeans)

  • Know what a Node is.
  • Know what an Explorer View is.
  • Know what the Explorer Manager is.
  • Know the relationship between Nodes and Explorer Views.
  • Be familiar with how explorer views work (looking up the hierachy for something to display them).

Potential Demos/Homework for Presentation (one or more of these)

  • Put the explorer views in the IDE's Palette before the presentation. Then, during the presentation, create a Node (e.g., a Node for the folders and files on disk). Then show how the explorer views can be switched without needing to do any re-coding: i.e., just drag and drop the explorer views to replace them. Do this whole demo in a Java application, i.e., outside the NetBeans Platform.
  • Migrate the above demo to the NetBeans Platform, then explain the advantages of having done so.

Presentation: Data Objects and Editors (a.k.a. NetBeans ~ OS/2 )

  • Know what a Data Object is.
  • Know how a Data Object relates to a Node.
  • Know how to create a Data Object (i.e., via the File Type wizard)
  • Know how DataLoaders work.
  • Know about Schliemann.

Potential Demos/Homework for Presentation (one or more of these)

  • Use the File Type wizard to create a basic DataObject and use it to recognize some new file type.
  • Create a Schliemann editor.
  • Talk about editor APIs that can be used to extend the NetBeans Java editor and do a demo on a few of these.

Presentation: Window System

  • Know what the NetBeans Window System is and what it offers
  • Know how to create a TopComponent, via the New Window Component wizard
  • Be familiar with how the System FileSystem relates to the Window System
  • Be familiar with the TopComponent API class
  • Have heard about the WindowManager API class
  • Have heard about the TopComponentGroup API class
  • Have heard about Modes
  • Have heard about persistence
  • Have heard about the XML layout files, like WSTCREF and WSGRP

Potential Demos/Homework for Presentation (one or more of these)

  • Create a TopComponent via the Window Component wizard.
  • Move the TopComponent around, minimize it, maximize it, undock it, dock it, etc.
  • Say: All this is for free, every TopComponent has all this functionality by default.
  • Show differences between TopComponent in 5.5, 6.0, 6.1.
  • Port the Anagram Game to the NetBeans Platform.

Presentation: Contributing to Open Source Projects

  • Know how the NetBeans sources can be checked out.
  • Know how to create a new issue in Issuezilla.
  • Know about the main mailing lists.
  • Be familiar with the basic NetBeans source structure.

Potential Demos/Homework for Presentation (one or more of these)

  • Check out the NetBeans sources (but make sure it will be fast or make sure the course lasts long enough)
  • Have the sources checked out and browse through them.
  • Go to Issuezilla, find an issue, and fix it. (You need to be Jarda to do this successfully.)

Presentation: Creating Java Editor Hint

  • Know the importance of Java editor hints to NetBeans IDE
  • Know how to get started creating Java editor hints
  • Know that they can create Java editor hints for their certification project
  • Be familiar with a simple example for Java Editor hints
  • Be familiar with where to find the sources of all other Java editor hints

Potential Demos/Homework for Presentation (one or more of these)

  • Show hints from the user's perspective (invoke a hint, show Options window)
  • Use the template to create a hint, install it, use it.
  • Explore the related NetBeans sources.

Presentation: Ideas for Modules

  • Know where the Wikis are with suggested projects
  • Know how to submit their own projects
  • Be familiar with Schliemann
  • Be familiar with Visual Library API

Potential Demos/Homework for Presentation (one or more of these)

  • Use Schliemann template to show how quickly new language support can be created.
  • Show the Linz page and the screenshot of the Prolog Editor by the student, also show the tutorial she created.
Not logged in. Log in, Register

By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2012, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo