1.Keep cleaning your hands. Use soap and water or an alcohol solution to sterilize the hands. 2.Keep a safe distance from anyone coughing or sneezing. 3.Do not touch your eyes, nose, or mouth. 4.Make sure to cover your mouth and nose by bending the elbow or a tissue with coughing or sneezing. 5.Go home if you feel sick. 6.If you have a fever, cough, and trouble breathing, seek medical attention.  7. Follow the directions of the local health authorities.


Delaware State University
Dr. Latha Melmaiee’s lab focuses on small fruit crop improvement for biotic and abiotic stress tolerance using physiology, genomics, and molecular breeding approaches
Some of the active programs are:
Other collaborative projects include:
Phenotyping of agronomically important traits and biotic and Germplasm improvement, breeding of small fruits (blueberries, strawberries, blackberries), and some specialty vegetable crops.
Integration of classical plant breeding and modern genomic tools to improve horticultural and nutraceutical traits.


Teenage Mutant Ninja Turtles Chad'z rating: *** (out of 4 = good) 1990, PG, 95 minutes [1 hour, 35 minutes] [adventure] starring: Judith Hoag (April O'Neil), Elias Koteas (Casey Jones), Josh Pais (voice of Raphael), Corey Feldman (voice of Donatello), Robbie Rist (voice of Michelanglo), Brain Tochi (voice of Leonardo), produced by Kim Dawson, Simon Fields, David Chan, written by Todd W. Langen, Bobby Herbeck, directed by Steve Barron, based on the comic book and characters created by Kevin Eastman and Peter Laird.
Now this is a first. For once, Hollywood was able to make a movie based on a popular [children's] trend that is not total stupidity. In fact, "Teenage Mutant Ninja Turtles" is really quite original as it combines some of the gritty elements from the comic book with storylines from the animated series to tell a lighthearted, campy story.
The setting takes place in New York City where some kind of invisible crime wave going on. As we hear the voice of journalist April O'Neil (Hoag) describe the situation, we see for ourselves just how masterminded the criminals are. Surprisingly, they are teenagers with the stealth and other abilities of ninjas. As April leaves she is mugged by some of the thieves, but they become victims themselves when someone puts out the lights and disarms them. Of course we know it's the turtles and we then proceed to follow them home and learn a bit about them.
The TMNTs are four, huge, mutated turtles who wear masks and are obviously ninjas. They live in the sewers with their mentor, a mutated rat named Splinter. The only problem is the story tries to counter the turtles' hyperness with the serious, metaphoric words of their sensi. One minute Splinter is giving an important analogy or proverb (a la Yoda in "The Empire Strikes Back"), and the next minute the guys are partying... but then again, they are teenagers.
Through some good cop-out devices, April finds herself warned by the Foot Clan (the perpetrators of the crime wave) to "shut it." She then meets the turtles after Raphael comes to her rescue. We also learn about the Foot's secret headquarters through a character with ties to April. There isn't much here in terms of explaining the genius of the criminal organization or why they are committing so much theft, just the fact they are ninjas, and therefore invisible, seems to be reason enough.
The Foot learns about the turtles, and kidnaps their master, and thus fight scenes ensue and a plot of sorts begins to form.  In fact, the general attitude of the film works like this as a whole. Yes, sometimes the script provides for fight scenes but there is actually a story and a fun spirit to it all.
If the film succeeds in any way, it would have to be the cleverly scripted and well choreographed fight scenes. They are hilarious because of the way the turtles fight, using household objects and all the while exclaiming wisecracks and one-liners. The violence isn't even graphic, but portrayed in such a way that we know who's winning.
I don't have to tell you how the film ends, it's typical but somewhat suspenseful. Considering all the elements that make up and surround the film, this is really quite an accomplishment.
Even if "Teenage Mutant Ninja Turtles" is just an exploitative children's film, the fact remains it has a decent story to tie it all together. Its lightheartedness gives it the charm those other adventure flicks miss.
Please visit Chad'z Movie Page @ http://members.aol.com/ChadPolenz - over 140 films reviewed in depth, not just blind ratings or quick capsules. E-mail<EMAIL_ADDRESS>(C)1997 Chad Polenz
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{% extends "base.html" %} {% load i18n %} {% block content %}
{% trans "An email containing password reset instructions has been sent to your email address on file" %}


The following diagrams emphasize the chord tones of the three-notes-per-string positions in C major, giving an arpeggio exercise that aligns with the 3-notes-per-string exercises.
This also serves as an example of processing and styling stops in two ways within a single diagram. Each genrated position is filtered into separate chord and non-chord tones, labels are assigned to the chord tones only, and the lists are then remerged. Additionally, the CSS for the non-chord tones is tweaked to de-emphasize them. Thus, we see the entire 3-notes-per-string position while reading only the arpeggio that sits atop it.
Made with Picker.js.


Spurs will struggle to find better than Pochettino, says Lineker
The former striker questioned his old club’s decision to sack the man who took them to last season’s Champions League final.
Tottenham will struggle to find a better manager than Mauricio Pochettino after opting to sack the Argentinian, according to Gary Lineker.
The former Spurs striker questioned the club’s decision to dispense with a man who led them to the Champions League final for the first time last season.
The club announced on Tuesday evening they had axed Pochettino following a disappointing start to the season.
Lineker said on Twitter: “He helped the club to punch massively above their weight for years. Good luck with finding a better replacement….ain’t gonna happen.”
Former England midfielder Trevor Sinclair blamed Totteham’s players for letting their manager down, tweeting: “Tottenham players need to have a look at themselves in the mirror tonight after what Poch has done for them #Pochettino.”
Former Liverpool defender Jamie Carragher backed Pochettino to be back managing in the Premier League soon.
He tweeted: “I said a few weeks ago I felt this project had ran its course, I thought there would be a change at the end of the season with either the manager or players changing. Pochettino has been a brilliant manager for Spurs & will be back in the PL sooner rather than later!.”


IntroductionCredit: Donn Cave, University of Washington In this chapter, we consider a class of programmerthe humble system administratorin contrast to other chapters' focus on functional domains. As a programmer, the system administrator faces most of the same problems that other programmers face and should find the rest of this book of at least equal interest. Python's advantages in the system administration domain are also quite familiar to other Python programmers, but Python's competition is different. On Unix platforms, at any rate, the landscape is dominated by a handful of lightweight languages such as the Bourne shell and awk that aren't exactly made obsolete by Python. These little languages can often support a simpler, clearer, and more concise solution than Python, particularly for commands that you're typing interactively at the shell command prompt. But Python can do things these languages can't, and it's often more robust when dealing with issues such as unusually large data inputs. Another notable competitor, especially on Unix systems, is Perl (which isn't really a little language at all), with just about the same overall power as Python, and usable for typing a few commands interactively at the shell's command prompt. Python's strength here is readability and maintainability: when you dust off a script you wrote in a hurry eight months ago, because you need to make some changes to it, you don't spend an hour to figure out whatever exactly you had in mind when you wrote this or that subtle trick. You just don't use any tricks at all, subtle or gross, so that your Python scrips work just fine and you don't burn your time, months later, striving to reverse-engineer them for understanding. One item that stands out in this chapter's solutions is the wrapper: the alternative, programmed interface to a software system. On Unix (including, these days, Mac OS X), this is usually a fairly prosaic matter of diversion and analysis of text I/O. Life is easy when the programs you're dealing with are able to just give clean textual output, without requiring complex interaction (see Eric Raymond, The Art of Unix Programming, http://www.faqs.org/docs/artu/, for an informative overview of how programs should be architected to make your life easy). However, even when you have to wrap a program that's necessarily interactive, all is far from lost. Python has very good support in this area, thanks, first of all, to the fact that it places C-level pseudo-TTY functions at your disposal (see the pty module of the Python Standard Library). The pseudo-TTY device is like a bidirectional pipe with TTY driver support, so it's essential for things such as password prompts that insist on a TTY. Because it appears to be a TTY, applications writing to a pseudo-TTY normally use line buffering, instead of the block buffering that gives problems with pipes. Pipes are more portable and less trouble to work with, but they don't work for interfacing to every application. Excellent third-party extensions exist that wrap pty into higher-level layers for ease of use, most notably Pexpect, http://pexpect.sourceforge.net/. On Windows, the situation often is not as prosaic as on Unix-like platforms, since the information you need to do your system administration job may be somewhere in the registry, may be available via some Windows APIs, and/or may be available via COM. The standard Python library _winreg module, Mark Hammond's PyWin32 package, and Thomas Heller's ctypes, taken together, give the Windows administrator reasonably easy access to all of these sources, and you'll see more Windows administration recipes here than you will ones for Unix. The competition for Python as a system administration language on Windows is feeble compared to that on Unix, which is yet another reason for the platform's prominence here. The PyWin32 extensions are available for download at http://sourceforge.net/projects/pywin32/. PyWin32 also comes with ActiveState's ActivePython distribution of Python (http://www.activestate.com/ActivePython/). To use this rich and extremely useful package most effectively, you also need Mark Hammond and Andy Robinson, Python Programming on Win32 (O'Reilly). ctypes is available for download at http://sourceforge.net/projects/ctypes. While it may sometimes be difficult to see what brought all the recipes together in this chapter, it isn't difficult to see why system administrators deserve their own chapter: Python would be nowhere without them! Who else, back when Python was still an obscure, fledgling language, could bring it into an organization and almost covertly infiltrate it into the working environment? If it weren't for the offices of these benevolent and pragmatic anarchists, Python might well have languished in obscurity despite its merits. |


UN definition: "Affordable, scalable solutions are now available to enable countries to leapfrog to cleaner, more resilient economies. The pace of change is quickening as more people are turning to renewable energy and a range of other measures that will reduce emissions and increase adaptation efforts."
Target 13.1: Strengthen resilience and adaptive capacity to climate-related disasters
Target: "Strengthen resilience and adaptive capacity to climate-related hazards and natural disasters in all countries."
Target 13.2: Integrate climate change measures into policy and planning
Target: "Integrate climate change measures into national policies, strategies and planning."
Target 13.3: Build knowledge and capacity to meet climate change
Target: "Improve education, awareness-raising and human and institutional capacity on climate change mitigation, adaptation, impact reduction and early warning."
Target 13A: Implement then UN Framework Convention on Climate Change
Target: "Implement the commitment undertaken by developed-country parties to the United Nations Framework Convention on Climate Change to a goal of mobilizing jointly $100 billion annually by 2020 from all sources to address the needs of developing countries in the context of meaningful mitigation actions and transparency on implementation and fully operationalize the Green Climate Fund through its capitalization as soon as possible."
Target 13B: Promote mechanisms to raise capacity for planning and management
Target: "Promote mechanisms for raising capacity for effective climate change-related planning and management in least developed countries and small island developing States, including focusing on women, youth and local and marginalized communities."


The top currently wished for items on the site
{{product.description | limitTo: 100 }}{{product.description.length > 25 ? '...' : ''}}
{{product.current_price | currency}}
Login to save your wish!


Episode 1: Pilot
EXPERIENCE THIS EPISODE'S INTERACTIVE CONTENT
Episode 2: World of Forgeries
Episode 3: Mind Clones
Episode 4: Biohacking
Episode 5: Holograms
Episode 6: Lab-Grown Materials
Episode 2: World of Forgeries
Episode 3: Mind Clones
Episode 4: Biohacking
Episode 5: Holograms
Episode 6: Lab-Grown Materials


NetBeans (@ http://netbeans.org) is an open-source Integrated Development Environment (IDE). NetBeans began in 1996 as a Java IDE student project at Charles University in Prague. Sun Microsystems acquired NetBeans in 1999. In 2010, Oracle acquired Sun (and thus NetBeans).
Compared with its rival Eclipse (http://www.elicpse.org) (both are open-source, so I don't know what are they competing for?), NetBeans provides seamless support for Java AWT/Swing, Java ME mobility pack, Java EE, and bundled with an excellent profiler for performance tuning.
How to Install NetBeans 8.1
For Windows
Step 0: Install JDK
To use NetBeans for Java programming, you need to first install Java Development Kit (JDK). See "JDK - How to Install".
Step 1: Download
Download "NetBeans IDE" installer from http://netbeans.org/downloads/index.html. There are many "bundles" available. For beginners, choose the "Java SE" (e.g., "netbeans-8.1-javase-windows.exe
").
Step 2: Run the Installer
Run the downloaded installer.
For Mac
Read "How to Install NetBeans on Mac".
For Ubuntu Linux
Read "How to Install NetBeans on Ubuntu".
Writing a Hello-world Java Program in NetBeans
Step 0: Launch NetBeans
Launch NetBeans. If the "Start Page" appears, close it by clicking the "close" button.
Step 1: Create a New Project
For each Java application, you need to create a "project" to keep all the source files, classes and relevant resources.
- From "File" menu ⇒ Choose "New Project...".
- In "Choose Project" diglog ⇒ Under "Categories", choose "Java" ⇒ Under "Projects", choose "Java Application" ⇒ "Next".
- In "Name and Location" ⇒ Under "Project Name", enter "
FirstProject
" ⇒ In "Project Location", select a suitable directory to save your works ⇒ Uncheck "Create Main class" ⇒ Finish.
Step 2: Write a Hello-world Java Program
- Right-click on "
FirstProject
" ⇒ "New" ⇒ "Java Class..." (OR from the "File" menu ⇒ "New File..." ⇒ Categories: "Java", File Types: "Java Class" ⇒ "Next"). - In "Name and Location" ⇒ Under "Class Name", enter "
Hello
" ⇒ Delete the content in "Package" if it is not empty ⇒ "Finish". - The source file "
Hello.java
" appears in the editor panel. Enter the following codes:/** First Java Program to say Hello wrold */ public class Hello { public static void main(String[] args) { System.out.println("Hello, world"); } }
Step 3: Compile & Execute
There is no need to "compile" the source code explicitly, as NetBeans performs the so-called incremental compilation (i.e., the source statement is compiled while it is entered).
To run the program, right-click anywhere in the source (or from the "Run" menu), select "Run File" (or "Run Hello.java
"). Observe the output on the output console.
Notes:
- You should create a new Java project for each of your Java application.
- Nonetheless, NetBeans allows you to keep more than one programs in a project, which is handy for writing toy programs (such as your tutorial exercises). If you have more than one files with
main()
method in one project, you need to right-click the source and choose "Run File".
Step 4: Read the NetBeans Documentation
- At a minimum, you SHOULD READ the "IDE Basics, Getting Started, Java Application", which is accessible via NetBeans's "HELP" menu ⇒ "Help Contents".
- The "Help" ⇒ "Online Doc and Support" (@ http://netbeans.org/kb/index.html) contains many articles and tutorial on using NetBeans.
- The NetBeans "Start Page" also provides many useful links to get you started.
Debugging Program in NetBeans
Step 0: Write a Java Program
The following program computes and prints the factorial of n
(=1*2*3*...*n
). The program, however, has a logical error and produce a wrong answer for n
=20
("The Factorial of 20 is -2102132736
" - a negative number?!).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
/** Compute the factorial of n */ public class Factorial { // Print factorial of n public static void main(String[] args) { int n = 20; int factorial = 1; // n! = 1*2*3...*n for (int i = 1; i <= n; i++) { factorial *= i; } System.out.println("The Factorial of " + n + " is " + factorial); } } |
Let us use the graphic debugger to debug the program.
Step 1: Set an initial Breakpoint
A breakpoint suspends program execution for you to examine the internal states of the program. Before starting the debugger, you need to set at least one breakpoint to suspend the execution inside the program. Set a breakpoint at main()
method by clicking on the left-margin of the line containing main()
. A red circle or an inverted Triangle appears in the left-margin indicating a breakpoint is set at that line.
Step 2: Start Debugging
Right click anywhere on the source code ⇒ "Debug File". The program begins execution but suspends its operation at the breakpoint, i.e., the main()
method.
As illustrated in the following diagram, the highlighted line (also pointed to by a green arrow) indicates the statement to be executed in the next step.
Step 3: Step-Over and Watch the Variables and Outputs
Click the "Step Over" button (or select "Step Over" in "Debug" menu) to single-step thru your program. At each of the step, examine the value of the variables (in the "Variable" panel) and the outputs produced by your program (in the "Output" Panel), if any. You can also place your cursor at any variable to inspect the content of the variable.
Single-stepping thru the program and watching the values of internal variables and the outputs produced is the ultimate mean in debugging programs - because it is exactly how the computer runs your program!
Step 4: Breakpoint, Run-To-Cursor, Continue and Finish
As mentioned, a breakpoint suspends program execution and let you examine the internal states of the program. To set a breakpoint on a particular statement, click on the left-margin of that line (or select "Toggle Breakpoint" from "Run" menu).
"Continue" resumes the program execution, up to the next breakpoint, or till the end of the program.
"Single-step" thru a loop with a large count is time-consuming. You could set a breakpoint at the statement immediately outside the loop (e.g., Line 11 of the above program), and issue "Continue" to complete the loop.
Alternatively, you can place the cursor on a particular statement, and issue "Run-To-Cursor" to resume execution up to the line.
"Finish" ends the debugging session. Always terminate your current debugging session using "Finish" or "Continue" till the end of the program.
Other Debugger's Features:
Modify the Value of a Variable
You can modify the value of a variable by entering a new value in the "Variable" panel. This is handy for temporarily modifying the behaviour of a program, without changing the source code.
Step-Into and Step-Out
To debug a method, you need to use "Step-Into" to step into the first statement of the method. You could use "Step-Out" to return back to the caller, anywhere within the method. Alternatively, you could set a breakpoint inside a method.
NetBeans - Tips & Tricks
General Usage
These are the features that I find to be most useful in NetBeans:
- Maximizing Window (double-click): You can double-click on the "header" of any panel to maximize that particular panel, and double-click again to restore it back. This is particularly useful for editing source code in full panel.
- Code Auto-Complete (or Intelli-Sense) (ctrl-space): Enter a partial statement (e.g., Sys) and press control-space to activate the auto-complete, which displays all the available choices.
- Javadoc (ctrl-space, alt-F1): Place the cursor on a method or class, and press ctrl-space to view the javadoc; or right-click ⇒ Show Javadoc (alt-F1) to open it on a browser.
- Code Shorthand (tab): For example, you can enter "
sout
" and press TAB for "System.out.println
"; "psvm
" for "public static void main(String[] args) { }
" or "for
i" + tab for a for-loop. To view and configure code template, choose "Tools" menu ⇒ "Options" ⇒ "Editor" ⇒ "Code Templates". - Formatting Source Code (alt-shift-f): Right-click on the source (or from the "Source" menu) ⇒ Choose "Format". NetBeans will layout your source codes with the proper indents and format. To configure the formatting, choose "Tools" menu ⇒ "Options" ⇒ "Editor" ⇒ "Formatting".
You can also select the section of codes to be formatted, instead of the entire file. - Hints for Correcting Syntax Error: If there is a syntax error on a statement, a red mark will show up on the left-margin on that statement. You could click on the "light bulb" to display the error message, and also select from the available hints for correcting that syntax error.
- Rename (Refactor) (ctrl-r): To rename a variable, place the cursor on that variable, right-click ⇒ "Refactor" ⇒ "Rename" ⇒ Enter the new name. All the appearances of that variables in the project will be renamed.
- Small Programs: You can keep many small toy programs (with
main()
) in one Java project instead of create a new project for each small program. To run the desired program, on the "editor" panel ⇒ right-click ⇒ "Run File". - Source Toggle Comment: To temporarily comment-off a block of codes, choose "Source" ⇒ "Toggle Comment".
- Error Message Hyperlink: Click on an error message will hyperlink to the corresponding source statement.
- Command-Line Arguments: To provide command-line arguments to your Java program in NetBeans, right-click on the "project" ⇒ "Set as Main Project" ⇒ "Set Configurations" ⇒ "Customize..." ⇒ "Run" ⇒ select the "Main" class ⇒ type your command-line arguments inside the "Arguments" field ⇒ choose "Run" menu ⇒ "Run Main Project".
- Line Numbers: To show the line numbers, right-click on the left-margin ⇒ "Show Line Numbers".
- Changing Font Face and Size: Tools ⇒ Options ⇒ Fonts & Colors ⇒ In "Category", select "Default" ⇒ In "Font", choose the font face and size.
- Resetting Window View: If you mess up the window view (e.g., you accidentally close a window and cannot find it anymore), you can reset the view via "Window" menu ⇒ "Reset Windows".
- Code Templates: For example, when you create a new Java class, NetBeans retrieves the initial contents from the "Java Class" code template. To configure code templates, select "Tools" menu ⇒ "Templates" ⇒ Choose the desired template ⇒ "Open in Editor". To set a value of a variable used in the all the code templates (e.g.,
$User
), select "Tools" menu ⇒ "Templates" ⇒ "Settings". - Displaying Chinese Character: Need to choose a font that support chinese character display, such as "Monospace", in Tools ⇒ Options ⇒ Fonts & Colors ⇒ Syntax ⇒ default.
- Changing the JDK Location: The Netbeans configuration file is located at "
etc\netbeans.conf
". Edit the directive "netbeans_jdkhome
". - Let me know if you have more tips to be included here.
Java Application Development
- Choosing the JDK version for your program: Right-click on your project ⇒ "Properties" ⇒ "Source" node ⇒ You can select the JDK level of your project in pull-donw menu "Source/Binary Format".
- Enabling JDK 7 support: If JDK 7 is already installed in your system, right-click on your Project ⇒ "Properties" ⇒ "Source" node ⇒ "Source/Binary Format" ⇒ Select "JDK 7". Also check "Libraries" ⇒ Java Platform ⇒ JDK 7.
If JDK 7 is not installed/configured, install JDK 7. Add JDK 7 support to NetBeans via "Tool" menu ⇒ "Java Platforms" ⇒ "Add Platform...". - Choosing Default Charset: Right-click on your project ⇒ "Properties" ⇒ "Source" node ⇒ "Encoding" ⇒ choose your desired charset for the text-file I/O from the pull-down menu.
- Enabling Unicode Support for File Encoding: Right-click on your project ⇒ "Properties" ⇒ "Source" node ⇒ "Encoding" ⇒ choose your Unicode encoding (e.g., UTF-8, UTF-16, UTF-16LE, UTF-16GE) for the text-file I/O.
- To include Javadoc/Source: Use "Library Manager" (select the "Tools" menu ⇒ "Libraries"); or "Java Platform Manager" (select "Tools" menu ⇒ "Java Platforms")
- Adding External JAR files & Native Libraries (".dll", ".lib", ".a", ".so"): Many external Java packages (such as JOGL, Java3D, JAMA, etc) are available to extend the functions of JDK. These packages typically provide a "
lib
" directory containing JAR files (".jar
") (Java Archive - a single-file package of Java classes) and native libraries (".dll
", ".lib
" for windows, ".a
", ".so
" for Linux and Mac).
To include an external JAR file (".jar
") into a project: Expand the project node ⇒ Right-click on "Libraries" ⇒ "Add JAR/Folder..." ⇒ Select the desired JAR file or the folder containing the classes.
If the external package contains many JAR files, you could create a user library to contain all the JAR files, and add the library to all the projects that required these JAR files. From "Tools" menu ⇒ "Libraries" ⇒ "New Library..." ⇒ Enter a library name ⇒ Use "Add JAR/Folder..." to add JAR files into this library.
Many JAR files come with native libraries in the form of ".dll
", ".lib
" (for Windows) and ".a
", ".so
" for Linux/Mac. The directory path of these libraries must be included in JRE's property "java.library.path
". This can be done via right-click the project ⇒ Set Configuration ⇒ Customize... ⇒ Run ⇒ In "VM options", enter "-Djava.library.path=xxx
", wherexxx
is path of the native libraries.
Notes: The JAR files must be included in theCLASSPATH
. The native library directories must be included in JRE's property "java.library.path
", which normally but not necessarily includes all the paths from thePATH
environment variable. Read "External JAR files and Native Libraries".
Writing Java GUI (AWT/Swing) Application in NetBeans
Step 0: Read
- Java GUI Application Learning Trail @ http://www.netbeans.org/kb/trails/matisse.html.
- Swing Tutorial's "Learning Swing with the NetBeans IDE" @ http://docs.oracle.com/javase/tutorial/uiswing/learn/index.html.
Step 1: Create a New "Java Application" Project
- Launch NetBeans ⇒ File ⇒ New Project...
- Under "Categories", choose "Java" ⇒ Under "Projects", choose "Java Application" ⇒ Next.
- In "Project Name", enter "
FirstNetBeansGUI
" ⇒ Choose a suitable directory for your "Project Location" ⇒ Uncheck the "Create Main class" box ⇒ Finish.
Step 2: Write a Java File "JFrame Form"
- Right-click on the project "
FirstNetBeansGUI
" ⇒ "New" ⇒ "JFrame Form..." (or "Others" ⇒ "Swing GUI Forms" ⇒ "JFrame Form"). - In "Class Name", enter "
NetBeansSwingCounter
" ⇒ Finish. - Create the GUI Components visually:
- From the "Platte" panel ⇒ "Swing Controls" ⇒ Drag and drop a "
Label
", "TextField
", and "Button
" into the design panel. - Click on the "
jLabel1
" ⇒ In the "Properties" panel, enter "Count" in "text" (You can also single-click on thejLabel1
to change the text). Right-click on thejLable1
⇒ Change Variable Name ⇒ In "New Name", enter "lblCount
". - Similarly, for "
jTextField1
" ⇒ Change the "text" to 0, and change the "Variable Name" to "tfCount
" ⇒ Resize the text field if necessary. - For "
jButton1
" ⇒ Change the "text" to "Count", and change the "Variable Name" to "btnCount
".
- From the "Platte" panel ⇒ "Swing Controls" ⇒ Drag and drop a "
- Write the event handler for the button by double-clicking the button and enter the following codes:
private void btnCountActionPerformed(java.awt.event.ActionEvent evt) { count++; tfCount.setText(count + ""); }
- Create an instance variable
count
(just below the class declaration) as follows:public class Counter extends javax.swing.JFrame { int count = 0;
Step 3: Compile & Execute
Right-click the source and select "Run File".
Step 4: Study the Generated Source Code
Expand the "Generated Code" and study how the GUI builder declare, allocate and initialize the GUI Component
s in the initComponents()
. Note how the JButton
registers an ActionEvent
listener and how an inner class is used as the listener and provide the event handler actionPerformed()
. Also notice that the main()
method uses a Swing's worker to run the GUI on the Event-Dispatcher thread, instead of the main
thread, for thread-safe operations.
public class NetBeansSwingCounter extends javax.swing.JFrame { int count = 0; // Constructor to setup the UI via initComponents() public NetBeansSwingCounter() { initComponents(); } private void initComponents() { lblCount = new javax.swing.JLabel(); tfCount = new javax.swing.JTextField(); btnCount = new javax.swing.JButton(); setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); lblCount.setText("Counter"); tfCount.setText("0"); btnCount.setText("Count"); // Create an anonymous inner as the listener for the ActionEvent fired by btnCount btnCount.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { btnCountActionPerformed(evt); } }); // Laying out the components // ...... pack(); } // ActionEvent handler for btnCount private void btnCountActionPerformed(java.awt.event.ActionEvent evt) { count++; tfCount.setText(count + ""); } public static void main(String args[]) { // Setup the Look and Feel // ..... // Run the constructor on the Event-Dispatcher Thread for thread-safe java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new NetBeansSwingCounter().setVisible(true); } }); } // private variables private javax.swing.JButton btnCount; private javax.swing.JLabel lblCount; private javax.swing.JTextField tfCount; }
NetBeans and MySQL
Reference: "Connecting to a MySQL Database" @ http://netbeans.org/kb/docs/ide/mysql.html.
NetBeans (JavaEE) provides direct support to MySQL server. You can use NetBeans as a GUI client to access a MySQL server, as well as an administrative tool (e.g., starting and stopping the server).
Configuring NetBeans to Support MySQL
From NetBeans "Window" menu ⇒ Select "Services". The "Services" tab shall appear on the left pane
- Right-click on the "Databases" node ⇒ "Register MySQL Server". (If you have already registered a MySQL server, you can right-click on Server node "
MySQL Server at hostname:port
" ⇒ Properties, to modify its properties.) - Select the "Basic Properties" tab, enter the hostname, port number, root user and password.
- Select the "Admin Properties" tab:
- Leave the "Path/URL to admin tool" empty.
- In "Path to start command", enter "
<MYSQL_HOME>\bin\mysqld.exe
"; in the "Arguments", enter "--console
" - In "Path to stop command", enter "
<MYSQL_HOME>\bin\mysqladmin.exe
", in the "Arguments", enter "-u root -ppassword shutdown
".
- A server node "
MySQL Server at hostname:port
" appears.
Database Administration - Start/Stop the Server and Create Databases
- You can start the MySQL server by right-clicking on the server node ⇒ select "start". [There seems to be a problem here. If a "connection refused: connect" error occurs, enter the password again.]
- Once the MySQL server is started and connected, you can see the list of databases by expanding the MySQL server node. You can create a new database by right-clicking on it and choose "Create Database...".
Create a new Connection
You need a connection to manipulate data. You can create multiple connections with different users and default databases.
- Right-click on the "Databases" ⇒ "New Connection..." ⇒ Select the driver "MySQL Connector/J" ⇒ Next ⇒ Enter hostname, port number, default database, a general username and password ⇒ "Test Connection" (make sure that MySQL is started) ⇒ Finish.
- A connection node "
jdbc:mysql://hostname:port/defaultDatabase
" appears.
Manipulating Data via a Connection
- Right-click on a connection node (e.g., "
jdbc:mysql://hostname:port/defaultDatabase
") ⇒ Choose "Connect" (if not connected, provided that the MySQL server has been started). - You can expand the connection node to view all the databases.
- Expand an existing database. There are three sub-nodes "Tables", "View" and "Procedures". Right-click on the "Tables" to create table or execute command. Similarly, right-click on the "View" and "Procedures".
- To view/manipulate the records in a table, right-click on the selected table ⇒ You can choose to "View Data...", "Execute Command...", etc.
- You can right-click on the connection to "connect" or "disconnect" from the server.
Create a SQL Script and Run the Script
You can create a SQL script by right-clicking on a project ⇒ New ⇒ "SQL File". You can run the script by right-clicking on the SQL script ⇒ "Run File" ⇒ Select an existing connection (or create a new connection) to run the script. You could also run a single statement (right-click on the statement ⇒ Run Statement) or a selected group of statements (highlight the statements ⇒ Right-click ⇒ Run Selection).
Developing and Deploying Web Application in NetBeans
Read:
- "Introduction to Developing Web Applications" @ http://netbeans.org/kb/docs/web/quickstart-webapps.html.
- More articles in "Java EE & Java Web Learning Trail" @ http://netbeans.org/kb/trails/java-ee.html.
Web (HTTP) Servers
Configuring Web Server
You could configure the web server via "Tools" menu ⇒ "Servers".
Tomcat Server
To configure Tomcat Server, select "Tools" menu ⇒ "Servers" ⇒ click "Add Servers":
- Choose Server: Select the desired Tomcat version ⇒ Next.
- Installation and Login Details: In "Server Location", fill in the Tomcat installation directory ($CATALINA_HOME) ⇒ Enter the username/password of a tomcat user with "manager" role. You could either check the "create user if it does not exist" or define the tomcat user in "
$CATALINA_HOME\conf\tomcat-users.xml
" as follows:<tomcat-users> <role rolename="manager"/> <user username="tomcatmanager" password="xxxx" roles="manager,manager-script,admin" /> </tomcat-users>
Running the Web Server
Choose "Services" ⇒ Expand "Servers" node ⇒ Right-click on the desired server ⇒ Start/Stop/Restart.
MySQL Database Server
You can also manage the MySQL database server directly from Tomcat. Read "NetBeans and MySQL" Section.
Writing a Hello-World Servlet/JSP Web Application
Create a New Servlet/JSP Project
- From "File" menu ⇒ choose "New Project...".
- "Choose Project" ⇒ Under "Categories", choose "Java Web" ⇒ Under "Projects", choose "Web Application" ⇒ "Next".
- "Name and Location" ⇒ In "Project Name", enter "
HelloServletJSP
" ⇒ In "Project Location", select a suitable directory to save your works ⇒ Check "Set as Main Project" ⇒ Next. - "Server and settings" ⇒ Choose your server, or "add" a new server ⇒ Next.
- "Frameworks" ⇒ Select none for pure servlet/JSP application ⇒ Finish.
Writing a Hello-World JSP
A JSP page called "index.jsp
" is automatically created, which says "Hello world!". To execute this JSP, right-click on the project ⇒ "Run". The URL is http://localhost:8080/HelloServletJSP/index.jsp
.
Writing a Hello-World Servlet
- Right-click on the project "
HelloServletJSP
" ⇒ New ⇒ Servlet. - "Name and Location" ⇒ In "Class Name", enter "
HelloServlet
" ⇒ In "Package", enter "hello
" ⇒ Next. - "Configure Servlet Deployment" ⇒ In "Servlet Name", enter "
HelloServletExample
" ⇒ In "URL Pattern", enter "sayhello
" ⇒ Finish. - Enter the following codes for "
HelloServlet.java
":package hello; import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class HelloServlet extends HttpServlet { @Override public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { // Set the response message's MIME type (in Content-Type response header) response.setContentType("text/html;charset=UTF-8"); // Get an output Writer to write the response message over the network PrintWriter out = response.getWriter(); // Write the response message (in an HTML page) to display "Hello, world!" try { out.println("<!DOCTYPE html>"); out.println("<html>"); out.println("<head><title>Hello Servlet</title></head>"); out.println("<body><h1>Hello, World (from Java Servlet)!</h1></body>"); out.println("</html>"); } finally { out.close(); // Always close the output writer } } }
- To execute the servlet: Right-click on the project ⇒ run ⇒ Change the URL to
http://localhost:8080/HelloServletJSP/sayhello
.
Generating a WAR-file for a Web Application
A WAR (Web Archive) file is basically a zip file for distributing web application in single file. You can use WinZip or WinRAR to inspect or unzip the war file.
To distribute the project as a war-file, right-click project ⇒ "Clean and Build". The war file is created in the "dist
" directory. You can deploy the web application by dropping the war-file into Tomcat's "webapps
" directory. Tomcat will automatically unzip the war-file and deploy the application upon startup.
Debugging Web Application
The most important reason for using IDE is to use the graphic debugger for debugging the program. You can set a breakpoint in your server-side Java codes, and "Debug" a web application, similar to a standalone application.
Writing a Hello-world JSF 2.0 Web Application
Create a New JSF 2.0 Project
- From "File" menu ⇒ choose "New Project...".
- "Choose Project" ⇒ Under "Categories", choose "Java Web" ⇒ Under "Projects", choose "Web Application" ⇒ "Next".
- "Name and Location" ⇒ In "Project Name", enter "
HelloJSF20
" ⇒ In "Project Location", select a suitable directory to save your works ⇒ Check "Set as Main Project" ⇒ Next. - "Server and settings" ⇒ Choose your server, or "add" a new server ⇒ Next.
- "Frameworks" ⇒ Check "JavaServer Faces" ⇒ In "Libraries", "Registered Libraries", select "JSF 2.0" ⇒ Finish.
- An "
index.xhtml
" JSF page is generated, as follows:<?xml version='1.0' encoding='UTF-8' ?> <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html"> <h:head> <title>Facelet Title</title> </h:head> <h:body> Hello from Facelets </h:body> </html>
To run this facelet, right-click on the project ⇒ Run.
Create a new JSF 2.0 Facelet
- Right-click on the project ⇒ New ⇒ "Other..."
- "Choose File Type" ⇒ Under "Category", select "JavaServer Faces" ⇒ Under "File Type", select "JSF Page" ⇒ Next.
- "Name and Location" ⇒ In "File Name", enter "
HelloJSF20
" ⇒ In "Options", check "Facelets" ⇒ Finish. - In "
HelloJSF20.xhtml
", enter the following codes:<?xml version='1.0' encoding='UTF-8' ?> <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html"> <h:head> <title>Hello JSF 2.0</title> </h:head> <h:body> <h1>Hello from Facelets</h1> </h:body> </html>
- To execute the JSF page, right-click on the project ⇒ Run ⇒ Change the URL to
http://localhost:8080/HelloJSF20/HelloJSF20.xhtml
.
Writing a Hello-world JSF 1.2 Web Application
Create a New JSF 1.2 Project
- From "File" menu ⇒ choose "New Project...".
- "Choose Project" ⇒ In "Categories", choose "Java Web" ⇒ In "Projects", choose "Web Application" ⇒ "Next".
- "Name and Location" ⇒ In "Project Name", enter "
HelloJSF12
" ⇒ In "Project Location", select a suitable directory to save your works ⇒ Check "Set as Main Project" ⇒ Next. - "Server and settings" ⇒ choose your server, or "add" a new server ⇒ Next.
- "Frameworks" ⇒ Check "JavaServer Faces" ⇒ In "Libraries", "Registered Libraries", select "JSF 1.2" ⇒ Finish.
- A "
WelcomeJSF.jsp
" page is generated, as follows:<%@page contentType="text/html" pageEncoding="UTF-8"%> <%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%> <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%> <!DOCTYPE html> <%-- This file is an entry point for JavaServer Faces application. --%> <f:view> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/> <title>JSP Page</title> </head> <body> <h1><h:outputText value="JavaServer Faces"/></h1> </body> </html> </f:view>
To run this page, right-click on the project ⇒ Run.
Create a new JSF 1.2 Page
- Right-click on the project ⇒ New ⇒ "Other..."
- "Choose File Type" ⇒ In "Category", select "JavaServer Faces" ⇒ In "File Type", select "JSF Page" ⇒ Next.
- "Name and Location" ⇒ In "File Name", enter "
HelloJSF12
" ⇒ In "Options", check "JSP File (Standard Syntax)" ⇒ Finish. - In "
HelloJSF12.jsp
", enter the following codes:<%@page contentType="text/html" pageEncoding="UTF-8"%> <%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%> <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%> <!DOCTYPE html> <f:view> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/> <title>Hello JSF 1.2</title> </head> <body> <h1><h:outputText value="Hello World!"/></h1> </body> </html> </f:view>
- To execute the JSF page, right-click on the project ⇒ Run ⇒ Change the URL to
http://localhost:8080/HelloJSF12/faces/HelloJSF12.jsp
.
Debugging Web Applications in NetBeans
You can debug a webapp just like standalone application. For example, you can set breakpoints, single-step through the programs, etc.
REFERENCES & RESOURCES
- NetBeans mother site @ http://netbeans.org.
- NetBeans "Help" menu.


The Astutian
HOME
(current)
SERVICES
CONTACT
BLOG
Contact us
You can reach us through: Mail<EMAIL_ADDRESS>Phone number: +234-802-986-4891 (Whatsapp)
wordpress themes by
wpicus


Hi everyone. I'm Minh Nguyen . I am a student currently pursuing a Bachelor's Degree in Computer Science at Sacramento State University.
My interests:
I would like to learn more about
- Java
- Codename One
- C / C++
- SQL
- HTML
- CSS
- JavaScript
- Python
- Week 4:
Fun with Javascript: Fancify
- Week 5:
Week 5 module: Show clock
- Week 6:
Week 6 module: Encrypt It
- Week 12:
Week 12 module: Login
Quote:
If you don't know where you are going, any road will get you there. _ Lewis Carroll.


| LAPORAN | ||
|---|---|---|
| CORPORATE SOCIAL RESPONSIBILITY | ||
TOR ( TERM OF REFERENCE )LAPORAN KEGIATAN SARANA DAN PRASARANAPT INDONESIA POWER UNIT PEMBANGKITAN SEMARANG |
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right at the coast of the Semantics, a large language ocean. A small river named Duden flows by their place and supplies it with the necessary
Deskripsi Maksud dan Tujuan
Deskripsi Jadwal Rencana Pelaksanaan
Deskripsi Anggaran Tersedia
Deskripsi Pelaksanaan Kegiatan
| No. | Uraian | Volume | Satuan | Harga Satuan (Rp) | Jumlah |
|---|---|---|---|---|---|
| Total | Rp. 2.000.000,00 |


NHibernate
Simplistic "get started" code for NHibernate (version 1.2, 2 and 3).
- Download the latest version from NHForge.org
- In your data access layer, reference the NHibernate.dll
- Optional extras include Fluent mapping and NHibernate.Caches
- From v2.1 up to 3.2, add the proxy generator such as Castle- after v.3.2 it's built in
- For version 2 consider Lambda Extensions (it's superceded in v3).
- Create the configuration (contains connection string).
- Create the domain entities. Entities are mostly POCOs but you probably should inherit from a base class for identity.
- Create the mapping to the database tables (in hbm.xml or use Fluent mapping)
- In Application Start create the session factory (don't create it for every session or operation).Simplest is to hold it in a static or singleton object such as a SessionManager.
- Open an ISession from the Session Factory (in asp.net you may use an IHttpModule; in MVC a global ActionFilter). Use Load/Get/SaveOrUpdate etc- then Flush/Commit to database. In asp, typically create a session with a begin request, but you could store it in Session to span requests ("conversations"). Ideally create repositories (data access objects) for each domain entity, using the SessionManager.
For quick-start database-driven NHibernate, check out my Database schema reader which has a simplistic code generator.
Example Domain
Here we just use Category and Product from Northwind.
- Sample entities
- EntityBase - a base class overriding GetHashCode and Equals.
- Sample hbm (and fluent) mapping
- ProductRepository
Here are the same entities in ActiveRecord- the mapping is done by property attributes.
NHibernate helpers
- App.config - minimum required settings. And Fluent configuration in code.
- SessionManager - configure NHibernate and create sessions
NHibernate helpers - optional
- GenericRepository
- TransactionRequired- transaction wrapper
- IHttpModule for hooking up asp.net
- UnitOfWork - an IDisposable wrapper
- Unit test - putting it together


Beef. It's what's for dinner. Well, with some other stuff too. 8/14/2009, 6:49:50 PM Favs: 0 Retweets: 0 link


Home
FAQs
Application
Logout
Please submit your paperwork for final grade:
Upload:
Submit
Please submit your presentation, along with names of those who attended:
Upload:
Submit


6.1 Ecoinformatics
6.1.1 Michener et al, 2001
“Defining and unraveling biocomplexity” (Michener et al. 2001)
Key contribution: This study’s primary contribution to the literature is a formal definition of biocomplexity, and an investigation of its emergence within the scientific disciplines. The article primarily discusses:
- Defining biocomplexity
- Examining the characteristics of biocomplexity
- Speculating on the future of biocomplexity
Biocomplexity - “properties emerging from the interplay of behavioral, biological, chemical, physical, and social interactions that affect, sustain, or are modified by living organisms, including humans,” as defined by (Michener et al. 2001)
Key notes:
- Biocomplexity exists in contrast to the Popperian type of reductionalist science (causality & falsification), and recognizes that reduced causal mechanisms often are not robust within real-world situations
- “myriad confounding factors operating at different temporal and spatial scales”
- Two features of “biocomplexity”
- biocomplexity occurs as temporal, spatial and conceptual boundaries are broken-down and worked across
- emergent & unexpected properties may (or likely will) arise in response to biocomplexity
Characteristics of “biocomplexity”:
- Relevant for a wide range of organisms; from microbial to megafauna (including humans)
- Relevant for a wide range of environments
- Reflected in nonlinear, chaotic, or unpredictable behaviors – which likely necessitates sophisticated and innovative quantitative procedures
- Likely to span many hierarchical levels as well as across multiples scales in time and space
Key research trajectories for ecology (as posed by Thompson 2001):
- “Dynamics of coalescence in complex communities” - how do environmental constraints and species availability result in current complex ecological communities
- “Ecological memory” - how do past events & conditions influence current ecological structure and conditions
- “Emergent properties” - examining whether the first principles of “hard” sciences can predict composition, structure & function
- “Ecological topology” - identifying “rules” that occur over different scales of time and space, and examining how they interact to produce ecosystems
Further reading:
- (Thompson et al. 2001) - Frontiers of ecology: As ecological research enters a new era of collaboration, integration, and technological sophistication, four frontiers (listed above) seem paramount for understanding how biological and physical processes interact over multiple spatial and temporal scales to shape the Earth’s biodiversity
6.1.2 Jones et al, 2006
“The new bioinformatics: Integrating ecological data from the gene to the biosphere” (Jones et al. 2006)
Key contribution: This paper makes the case for “locating, accessing and integrating” data within ecology. They provide examples of the successes associated with doing so in alternative fields (genetics), and make a case for the need within ecology. They also outline vertically integrated databases (data warehouses) versus metadata-driven databases (data collections), and the relative pros/cons of the two.
Examples of metadata and data collections in ecology:
Key notes: Some relevant points from the article:
- A focus on “experimental” design and testing of multiple hypotheses makes ecological data inherently heterogeneous.
- Ecoinformatics importance is housed in ability to “allow a broader perspective over time and space, and across many disciplines, than is possible from on or a few studies,” and in allowing data to be reused for questions that may emerge in the future.
- Would appear to be well-suited to address questions of biocomplexity
- Current standard for storing of data is in heterogeneous spreadsheets
- Data warehouses (vertically-integrated) - databases that coalesce data from many investigators, but focus on one theme and are searchable often through an online interface
- Often represents a “least-common denominator” approach in that they are less complex than original dataset
- Examples: GenBank, VegBank or TreeBase
- Data collections (metadata-driven) - collection of datasets that are loosely structured together by well-crafted metadata. Some advantages are:
- Data of disparate types can be housed within a single location
- Focuses on project-level data and thus is familiar to researchers
- Metadata often more detailed
- Metadata often more precise and thus can be used in search functions
- Metadata standards - “consistent and rigorous sets of definitions for metadata categories that are broadly adopted by a research community.” Several examples exist within ecology:
- Ecological Metadata Language (EML)
- Biological Data Profile (BDP)
- Geographic Markup Language (GML)
- Knowledge Network for Biocomplexity (KNB) - a metadata-drive repo that provides mappings from EML to BDP (but not from BDP to EML as of time of article publication)
- Data islands - data derived from researchers working on disparate, autonomous topics that focus on specific, predetermined hypotheses
- Often subject to entrenched domain-specific vocabularies and also assumptions; ontologies may be a way of resolving this limitation
- Ontologies - well-defined concepts or terms that have precise meanings within a specific domain or field, as well as formal mappings of how the terms interrelate
- Science Environment for Ecological Knowledge (SEEK) - one example of a system developing ontologies within ecology
Further reading:
- Look into metadata languages (e.g., EML)
- Look into some of the earlier work on databases by Michener
6.1.3 Michener, 2006
“Meta-information concepts for ecological data management” (Michener 2006)
Definitions:
- Metadata - information about data, i.e. higher level descriptions of data
- Meta-information - information derived from subsequent data processing and analyses; are these data products?
Key contribution: Michener outlines some of the key criteria, challenges and opportunities for metadata within an ecological context.
Notes on metadata:
Some benefits of metadata include:
- Longevity of the data is greatly increased
- Reuse of the data both by the original researcher and others is facilitated
- Well-documented data may be used to expand scale of ecological inquiry
The primary functionality of metadata is:
- Supports data discovery (most basic level)
- Facilitates the acquisition and use of data by humans (requires additional metadata)
- Enables automatic discovery, ingestion and analysis of data (requires more sophisticated metadata), which needs:
- research context (hypothesis, study site, experimental design, etc.)
- status of dataset
- physical structure of dataset
- info to facilitate use and comprehension
Ecological Metadata Language (EML):
- EML is a standard for metadata that provides structure that supports automated functions of metadata listed above and is implemented in eXtensible Markup Language (XML)
- Organized into modules, such as “dataset”, “access”, “physical”, “party coverage”, “project”, “methods”, “datatable”, “attribute”, and “physical”
- Additional info at ecoinformatics.org
6.1.4 Bekker et al, 2007
“Long term datasets: From descriptive to prescriptive data using ecoinformatics” (Bekker et al. 2007)
Key contribution: This is the lead article to a special issue in Journal of Vegetation Science that focuses on ecoinformatics driven approaches to understanding complexity within vegetation systems. The article is less informative in its own right as much as a good pointer to other key studies working with vegetation science and ecoinformatics. It appears to be one of the earliest applications of ecoinformatics to vegetation science.
Further reading:
- Le Duc, 2007 - A database application for long-term ecological field experiments
- Peacock, 2007 - The RAINFOR database, for monitoring forest biomass and dynamics
6.1.5 Hale & Hollister, 2009
“Beyond data management: How ecoinformatics can benefit environmental monitoring programs” (Hale and Hollister 2009)
Key contribution: This is a less seminal study. They describe the relevance of ecoinformatics for environmental monitoring, but do not go much beyond some of the other pieces on ecoinformatics and its relevance for ecology. Some relevant points that stood out to me:
- Standardization of taxonomic classes may be facilitated by ecoinformatics and application of ontologies in ecoinformatics
- Establishing standards and protocols can help in synthesizing studies and results across time and space
Note: Likely better to focus on other studies within the literature than this one as they don’t bring up many points beyond those expressed in more seminal works.
6.1.6 Feller et al, 2010
“Biocomplexity in mangrove ecosystems” (Feller et al. 2010)
Key contribution: Aim to elucidate the factors playing in at different hierarchical levels in mangrove ecosystems (biocomplexity). They use emergent properties (which they define as “patterns or processes that occur at multiple hierarchical levels within ecosystems”) to examine underlying ecological processes within mangroves.
Biocomplexity appears to be thinking of ecology through a hierarchical lens, in which processes that exist at the “hard science” level (physics, chemistry, etc.) result in ecological processes > functions > services.
Key findings: The article doesn’t differ much from other reviews of controls on mangrove processes, apart from the structure in which they examine:
- Controls of emergent properties (namely specializations for variable salinity, flooding and nutrient availability)
- e.g., salinity tolerance, flooding tolerance, reproductive traits/regeneration, nutrient availability
- perhaps analogous to “ecosystem processes”
- Collective properties of forests (e.g., zonation, productivity, nutrient cycling, food webs)
- perhaps analogous to “functions”
- Emergent/collective properties of ecosystems & landscapes (e.g., habitat stability & connectivity of ecosystems)
- perhaps analogous to “services” or “benefits”
Emergent properties - concept that the whole is greater than the sum of its parts when examining ecological phenomena and the underlying processes that drive them. Emergent properties can exist at any scale, and may build upon themselves (e.g., morphology and physico-chemical conditions leading to ecophysiology (emergent property) which then leads to spatial assemblages (2nd emergent property), etc.). It may be helpful to think of different emergent properties at different scales of time and space.
Three primary characteristics of emergent properties exist:
- Emergent properties are not simply the sum of their parts
- Emergent properties exist as a type that is different from their underlying components
- They cannot be easily predicted from individual components
Examples of emergent properties within mangroves are ecophysiological traits (as listed above) that emerge from the interaction between biochemical and morphological traits with environmental factors.
Individual Based Models (IBMs) are discussed as useful though limited tools for examining biocomplexity within mangroves, but note that there is relatively little work in this field to date. See section 3.1.10 for an example of using IBMs within mangroves.
Relevance to research:
- Are IBMs relevant for research questions at hand?
6.1.7 Michener & Jones, 2012
“Ecoinformatics: Supporting ecology as a data intensive science” (Michener and Jones 2012)
Key contribution: This is a seminal study on the relevance of ecoinformatics written by two of the leading thinkers in the field.
Key notes: Several key notes from the study are:
- The authors describe the “data life cycle,”" with 8 steps that do not necessarily occur in sequential order and depend upon the analysis and research question at hand.
- The steps are:
- Plan - derive a data management plan that is often a living document as needs and uses for data will change over time
- Collect - there are highly variable mechanisms under which this occur given the vast amount of data types and collecting methods that exist; standardization in collection procedures is key for synthesizing data at later times
- Assure - measures taken to ensure data quality both before and after collection of the data; may consist of standardization of codes, units or metadata (e.g., using EML)
- Describe - sufficiently describing the data via metadata (who, what, when, where, why)
- Preserve - depositing of data in a repository such that they may be verified, maintained and accessed through time
- Discover - identifying appropriate data for research question of interest; double-edged sword in that you can get millions of hits or alternatively have tons of distinct data sources that exist only on disparate, local machines. DataONE is one such tool that drills down into data to identify datasets of actual interest; this is where ontologies come into play
- Integrate - understanding methodological differences, transforming to common representations and converting and recoding data to comparable semantics
- Analyze - reproducibility in analysis, with a particular focus on scientific workflows
DataONE: DataONE is a research platform that seeks to support the entire data life cycle, as well as integrate many different forms of data. There are three principle components:
- Member Nodes - contribute data, computing resources and services (e.g., data repositories, universities, computing centers)
- Coordinating Nodes - support network-wide services such as indexing, replication, and interactability of Member Nodes
- Investigator Toolkit - tools for researchers to employ in all steps of the data life cycle
Schematic of the data life cycle:
6.1.8 Soranno, 2014
“Cross-scale interactions: Quantifying multi-scaled cause – effect relationships in macrosystems” (Soranno et al. 2014)
Key significance: This study calls for a need for more explicit investigation of cross scale interactions (CSIs) both in time and space. They lay out a framework for investigating CSIs that consists of i) conceptual mapping, ii) construction of an appropriate database (ecoinformatics), and iii) modeling strategies that specifically investigate interactions (e.g., interaction terms in hierarchical modeling).
**Notes:**
The authors define two primary types of cross scale interactions (CSIs).
- Interactions among driver variables at different spatial scales that influence a focal resonse variable
- Interactions between transport processes that link fine- and broad-scaled processes
The authors explicitly model the interaction using Bayesian hierarchical models via an interaction term between regional and local driver variables.
Steps for quantifying CSIs:
- Conceptual model of cross-scale relationships that explicitly considers interactions and interdependencies. Development of the conceptual model is key to the process and entails four key components:
- Identifying relevant spatial and temporal extents and resolutions of driver variables
- Considering the types of the interactions that are expected
- Determining whether relationships are linear or nonlinear
- Identifying critical assumptions and uncertainties that may generate additional testable hypotheses
- Compilation of multi-scaled, multi-themed databases
- Summarize independent variables at multiple scales
- Resolve differences in data resolution
- This is where ecoinformatics is worked in
- Test for CSI as interaction term using Bayesian hierarchical models
The authors exemplify these steps in examining P nutrient additions in lake ecosystems in the US. Specifically, they encounter the issue in that wetland cover surrounding lakes leads to both increases and decreases in concentrations of P. They hypothesize that there are interactive effects between agricultural presence and wetland presence on lake P, and model the cross spatial scale interactivity between the two as an interaction term.
The results are significant and lead the authors to additional hypotheses. The particular case study is facilitated by standardization of lake environmental quality data.
6.1.9 Ruegg, 2014
“Completing the data life cycle: Using information management in macrosystems ecology research” (Rüegg et al. 2014)
Key contribution: This article promotes the premise that macrosystem ecology requires integrated information management at its inception. In calling for “completing the data cycle,” they refer to well-documenting datasets such that data may be re-used to answer new and different questions from those that are conceived by those involved in the original projects.
The article is largely an extension of Michener and Jones (2012), and argues largely for extensive documentation of datasets to enhance longevity.
Notes: The study notes several key areas within the data life cycle:
- Data collection: Incorporating information management early within the data collection process; critical to consider the structure and longevity of the dataset prior to collection such that it may be built upon and reused in the future
- Data integration (1): Integrating data from many sources. Currently integration is not possible through an automated manner, though tools exist to help in data integration
- Data integration (2): Integrating data from local observations to models and back requires unique considerations. Must understand spatial resolution of different datasets (e.g., field and RS data). Spatial and temporal issues exist for interpolation of field (e.g., point) datasets.
- “Completing the data cycle”: Documenting well and sharing facilitate analysis. Tools that show full data provenance and work flow can be effective in showing the full analysis and collection of a particular dataset.
References
Michener, William K, Thomas J Baerwald, Penelope Firth, Margaret A Palmer, James L Rosenberger, Elizabeth A Sandlin, and Herman Zimmerman. 2001. “Defining and Unraveling Biocomplexity.” BioScience 51 (12): 1018–23. doi:10.1641/0006-3568(2001)051[1018:DAUB]2.0.CO;2.
Thompson, John N, OJ Reichman, Peter J Morin, Gary A Polis, Mary E Power, Robert W Sterner, Carol A Couch, et al. 2001. “Frontiers of Ecology: As Ecological Research Enters a New Era of Collaboration, Integration, and Technological Sophistication, Four Frontiers Seem Paramount for Understanding How Biological and Physical Processes Interact over Multiple Spatial and Temporal Scales to Shape the Earth’s Biodiversity.” BioScience 51 (1): 15–24. doi:10.1641/0006-3568(2001)051[0015:FOE]2.0.CO;2.
Jones, Matthew B, Mark P Schildhauer, OJ Reichman, and Shawn Bowers. 2006. “The New Bioinformatics: Integrating Ecological Data from the Gene to the Biosphere.” Annual Review of Ecology, Evolution, and Systematics 37. doi:10.1146/annurev.ecolsys.37.091305.110031.
Michener, William K. 2006. “Meta-Information Concepts for Ecological Data Management.” Ecological Informatics 1 (1): 3–7. doi:10.1016/j.ecoinf.2005.08.004.
Bekker, Renée M, Eddy van der Maarel, Helge Bruelheide, and Kerry Woods. 2007. “Long-Term Datasets: From Descriptive to Predictive Data Using Ecoinformatics.” Journal of Vegetation Science 18 (4): 458–62. doi:10.1111/j.1654-1103.2007.tb02559.x.
Hale, Stephen S, and Jeffrey W Hollister. 2009. “Beyond Data Management: How Ecoinformatics Can Benefit Environmental Monitoring Programs.” Environmental Monitoring and Assessment 150 (1-4): 227. doi:10.1007/s10661-008-0675-x.
Feller, Ilka C, CE Lovelock, U Berger, KL McKee, SB Joye, and MC Ball. 2010. “Biocomplexity in Mangrove Ecosystems.” Annual Review of Marine Science 2: 395–417. doi:10.1146/annurev.marine.010908.163809.
Michener, William K, and Matthew B Jones. 2012. “Ecoinformatics: Supporting Ecology as a Data-Intensive Science.” Trends in Ecology & Evolution 27 (2): 85–93. doi:10.1016/j.tree.2011.11.016.
Soranno, Patricia A, Kendra S Cheruvelil, Edward G Bissell, Mary T Bremigan, John A Downing, Carol E Fergus, Christopher T Filstrup, et al. 2014. “Cross-Scale Interactions: Quantifying Multi-Scaled Cause–effect Relationships in Macrosystems.” Frontiers in Ecology and the Environment 12 (1): 65–73. doi:10.1890/120366.
Rüegg, Janine, Corinna Gries, Ben Bond-Lamberty, Gabriel J Bowen, Benjamin S Felzer, Nancy E McIntyre, Patricia A Soranno, Kristin L Vanderbilt, and Kathleen C Weathers. 2014. “Completing the Data Life Cycle: Using Information Management in Macrosystems Ecology Research.” Frontiers in Ecology and the Environment 12 (1): 24–30. doi:10.1890/120375.