Author: dashorst
Date: Tue Jul 20 20:40:53 2010
New Revision: 965997
URL: http://svn.apache.org/viewvc?rev=965997&view=rev
Log:
Added directories
Added:
wicket/common/site/trunk/help/
wicket/common/site/trunk/help/email.md
wicket/common/site/trunk/help/index.md
wicket/common/site/trunk/help/irc.md
wicket/common/site/trunk/help/reportabug.md
wicket/common/site/trunk/help/support.md
wicket/common/site/trunk/meet/
wicket/common/site/trunk/meet/blogs.md
wicket/common/site/trunk/meet/buzz.md
wicket/common/site/trunk/meet/features.md
wicket/common/site/trunk/meet/index.md
wicket/common/site/trunk/meet/introduction.md
wicket/common/site/trunk/meet/vision.md
Added: wicket/common/site/trunk/help/email.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/help/email.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/help/email.md (added)
+++ wicket/common/site/trunk/help/email.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,4 @@
+---
+layout: default
+title: Get help via email
+---
Added: wicket/common/site/trunk/help/index.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/help/index.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/help/index.md (added)
+++ wicket/common/site/trunk/help/index.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,69 @@
+---
+layout: default
+title: Get help
+---
+
+There are two types of help available for Apache Wicket:
+
+1. Support from the Apache Wicket open source project
+
+2. Commercial Support
+
+## Support From the Apache Wicket Open Source Project
+
+If you are experiencing problems using Wicket please report your problem
+via the Issue Tracker. You may also find it useful to discuss your issues with
+the community on the Discussion Forums or join one of the Mailing Lists. Below
+are some resources to check before asking for help:
+
+* Issue Tracker
+* Discussion Forums
+* Mailing Lists
+* FAQ
+* IRC
+
+Before asking for help with your issue, it's a very good idea to search for
+your issue in the mailing list archives (via the Discussion Forums) and the
+FAQ. The majority of issues can be solved in this manner without having to
+send an email to the mailing list. If you don't find an answer, use the
+guidelines below when writing the e-mail.
+
+### How to Get Help
+
+Whenever you are reporting a problem, please be sure to include as much
+information as possible; the more we know, the better the chance of a quicker
+resolution.
+
+* which version of the software
+
+* what platform and JDK
+
+* any particular container being used - if so what version
+
+* stack traces generally really help! If in doubt include the whole thing;
+ often exceptions get wrapped in other exceptions and the exception right
+ near the bottom explains the actual error, not the first few lines at the
+ top. Its very easy for us to skim-read past unnecessary parts of a stack
+ trace.
+
+* log output can be useful too; sometimes enabling DEBUG logging can help your
+ code & configuration files are often useful
+
+### How to get help faster
+
+We can help you much quicker if you try the following
+
+* provide us with a JUnit test case that demonstrates your issue. e.g. if you
+ think you've found a bug, can you create a test case to demonstrate the bug?
+
+* submit a patch fixing the bug! (We also buy you beer when we meet you if you
+ submit bug fixes for memory leaks or performance related issues, if you can
+ run a profiler on your test case and attach the output as a file (or zipped
+ file if its huge) to the JIRA we can normally fix things much faster. e.g.
+ run JProfiler or YourKit on your code and send us the output. To find memory
+ leaks its quicker to resolve if you can tell us what classes are taking up
+ all of the RAM; we can normally figure out whats wrong from that.
+
+## Commerical Support
+
+TODO
\ No newline at end of file
Added: wicket/common/site/trunk/help/irc.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/help/irc.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/help/irc.md (added)
+++ wicket/common/site/trunk/help/irc.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,4 @@
+---
+layout: default
+title: Get help on IRC
+---
Added: wicket/common/site/trunk/help/reportabug.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/help/reportabug.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/help/reportabug.md (added)
+++ wicket/common/site/trunk/help/reportabug.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,136 @@
+---
+layout: default
+title: Report a bug
+---
+
+Wicket manages bug reports via the [Apache Jira
+site](http://issues.apache.org/jira/browse/WICKET)
+
+It requires you to register with the site, to avoid spamming, and attribute
+credit where its due. It's relatively painless. Much harder is writing a
+clear and concise bug report.
+
+Etiquette for a bug report is:
+
+1. **Always search for an existing bug report about the issue before adding
+ your own.** This can be tricky, but several duplicate bug reports just
+ cause an administration headache for developers. If in doubt you can
+ always post the details of the bug to the [mailing list](email.html), and
+ wait to be asked to submit a bug report by a dev. But the jira search
+ functionality is pretty good, so do have go.
+2. **Be clear and concise in your language.** Wording a short but useful
+ summary, with a description that contains all the steps leading up to the
+ error plus any extra circumstantial evidence, is not always easy, but its
+ vital to getting the issue resolved, and really valuable.
+3. **Watch the bug.** The developers may ask you for more information via the
+ issue comments, so its good practices to check in on the issue whilst its
+ still open.
+4. **Don't be shy of maintaining the issue.** If you find its a duplicate of
+ some other issue that was reported before yours, then mark it as a
+ duplicate, and watch the original. If you get more info on the bug, add it
+ as a comment. If it doesnt get noticed by a dev, try submitting a
+ quickstart or better still a patch. Ask for it to be reviewed via the
+ mailing list.
+
+You will be rewarded with [subtle
+kudos](https://issues.apache.org/jira/secure/ConfigureReport.jspa?versionId=-1&issueStatus=all&selectedProjectId=12310561&reportKey=com.sourcelabs.jira.plugin.report.contributions%3Acontributionreport&Next=Next)
+and the bug is much more likely to be fixed promptly.
+
+## Build a Quickstart
+
+See [getting started](/start/quickstart.html) for a good introduction to
+building a barebone Wicket project from one command. There is even a tool to
+let you customise the command for your project.
+
+Or you can watch Al Maw's excellent
+[screencast](http://herebebeasties.com/2007-10-07/wicket-quickstart) covering
+the whole process of installing and running Maven, and getting your Eclipse
+workspace set up.
+
+The Maven command provided there is the quickest way to get a working Wicket
+project that you can use to clearly demonstrate a bug.
+
+Once you have an example that shows the minimum conditions under which the
+issue occurs, then you can zip up the project and attach it to the relevant
+issue.
+
+When a Wicket dev [asks you to submit a
quickstart](https://issues.apache.org/jira/browse/WICKET-497?focusedCommentId=12521870&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_12521870),
+that is what they mean.
+
+That is far more useful than posting reams of your application code and
+telling everyone it doesn't work. The former will help diagnose the problem,
+the latter will mainly get you abused on the mailing list.
+
+## Submit a patch ##
+
+This is the most involved, but the most rewarding route ;-).
+In a nutshell this involves:
+ * Checking out the Wicket source code from the Subversion repository.
+ * Building it via mvn or IDE plugin.
+ * Proving the bug exists, either via a Quickstart, or writing a unit test.
+ * Submitting your fix as a Subversion patch file.
+
+This guide will outline how to do it with Eclipse + Subclipse + m2eclipse.
+If you prefer the command line, then start here:
[http://wicket.apache.org/building-from-svn.html]
+If you can provide a walk through for your IDE of choice then please do add it.
+
+### Setting up ###
+
+Using an Eclipse 3.4.x flavour of your choice add install the following plugins
+
+* [Subclipse for accessing Subversion](http://subclipse.tigris.org/) - Eclipse
update site URL http://subclipse.tigris.org/update_1.6.x
+* [m2eclipse for maven support](http://m2eclipse.sonatype.org/) - Eclipse
update site: http://m2eclipse.sonatype.org/update/
+
+I usually install the entire Subclipse plugin, and all of m2eclipse except the
Project configurators unless I am using a J2EE version of Eclipse.
+I had a spurious error when adding the m2eclipse update site, "No repository
found at http://www.md.pp.ru/~eu/12/"; but it didn't cause any problems with the
install.
+
+### Checking out Wicket from Subversion ###
+
+* **Add the Wicket Subversion repository** - Navigate to Window > Show
+ Perspective > Other... > SVN Repository Exploring (eclipse uses the term
+ perspective to mean a collection of views, and a view is one single panel
+ with some specific function like the navigator view or the editor view) In
+ the SVN Repositories tab on the left, right click > New > Repository
+ Location... and paste in the repository url:
+ http://svn.apache.org/repos/asf/wicket
+
+* **Checkout the code** - Click on the new Repository and navigate to: trunk
+ > right click > checkout as maven project. Some serious churning will now
+ occur as you download of Wicket source, and then maven crawls the internet
+ for all the required libraries. Seriously, go for a stroll in the sunshine;
+ the checkout and build took about 6minutes on my machine, and thats without
+ maven needing to download anything.
+
+* **Building Wicket** - All that waiting wasn't in vain, as you should now
+ have a fully checked out, dependency managed, built, possibly working,
+ Wicket code base.
+
+### Kick the tires ###
+
+* Create a Quickstart via the wicket-archetype-quickstart
+* Navigate to the pom.xml in your Quickstart project.
+* Set version element to the same value as the one found in the Wicket project
pom.xml (e.g. 1.4-SNAPSHOT)
+* The plugin should automagically resolve the quickstart's Wicket dependency
from the project rather than a .jar
+* Find WicketApplication.java
+* Click through to WebApplication class from the extends section of the class
definition.
+* If all is well, you should be taken to the Wicket project .java version of
WebApplication rather than a .class file from a .jar
+
+### Proving a bug exists ###
+
+* **Writing a unit test with WicketTester**
+
+### Submitting a patch ###
+
+* **Extract your changeset into a patch file** - As we don't all have commit
+ access to the svn repository, we need some other way of getting our changes
+ to the developers. This is done by making an svn patch file, essentially a
+ plain text diff, with some subversion specific formatting. With the
+ Subclipse plug-in creating a patch file is as simple as:
+
+ 1. Right click on the project root (e.g. wicket)
+ 2. > Team > Create Patch...
+ 3. Save In File System (and provide a filename, of the form **WICKET-<bug
id number>-fix.patch**)
+ 4. > Next >
+ 5. Patch Root: Project
+ 6. Finish, you now have your patch file where you chose to put it in step 3
+ 7. Attach it to the relevant bug report with any further information you have
Added: wicket/common/site/trunk/help/support.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/help/support.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/help/support.md (added)
+++ wicket/common/site/trunk/help/support.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,4 @@
+---
+layout: default
+title: Get help from companies
+---
Added: wicket/common/site/trunk/meet/blogs.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/meet/blogs.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/meet/blogs.md (added)
+++ wicket/common/site/trunk/meet/blogs.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,34 @@
+---
+layout: default
+title: Wicket related blogs
+---
+
+Any (open source) project exists solely because a community wants to support
+it. The Wicket community consists of the users and developers. There are many
+who want to share their experiences with Wicket and do so on the mailing
+lists , on several online media portals (for example The ServerSide and
+JavaLobby ), and on their blogs.
+
+Here is a list of regular Wicket bloggers, consisting of core contributers and
enthusiastic users.
+
+* [Wicket in Action](http://wicketinaction.com/) - Igor Vaynberg, Martijn
Dashorst
+* [Chillenious!](http://chillenious.wordpress.com/) - Eelco Hillenius
+*
[Jonathan](http://web.mac.com/jonathan.locke/iWeb/JonathanLocke/Blog/Blog.html)
- Jonathan Locke
+* [Here be beasties](http://herebebeasties.com/) - Al Maw
+* [Jeremy Thomerson](http://www.jeremythomerson.com/blog) - Jeremy Thomerson
+* [Codierspiel](http://technically.us/code) - Nathan Hamblen (runs on Wicket)
+* [Antwerkz](http://www.antwerkz.com/wp/) - Justin Lee
+* [System Mobile](http://www.systemmobile.com/?cat=4) - Nick Heudecker
+* [Geertjan](http://blogs.sun.com/geertjan) - Geertjan Wielenga
+* [A Wicket Diary](http://martijndashorst.com/blog) - Martijn Dashorst
+* [Wicket Praxis](http://www.wicket-praxis.de/blog/) - Michael Mosmann
+* [Mystic Coders](http://mysticcoders.com/blog) - Andrew Lombardi
+* [Wicket by Example](http://wicketbyexample.com/) - Community driven
+* [Yes Wicket!](http://yeswicket.com/) - French Wicket blog
+
+## Get your blog listed!
+
+If you think your blog is missing, then please send a message to one of the
+core contributors or the mailinglist. In the mean time you can add your blog
+to our wiki's [special blog
+page](https://cwiki.apache.org/WICKET/wicket-blogs.html).
\ No newline at end of file
Added: wicket/common/site/trunk/meet/buzz.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/meet/buzz.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/meet/buzz.md (added)
+++ wicket/common/site/trunk/meet/buzz.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,154 @@
+---
+layout: default
+title: Wicket Buzz
+---
+
+Wicket has appeared in the press in a variety of industry trade magazines,
+including Network World, ComputerWorld, IT World and Information Week.
+Presentations on Wicket have been delivered by Wicket team members at JavaOne
+in San Francisco, Javapolis and TheServerSide Java Symposium in Europe. The
+following are quotes from reviewers and users of Wicket:
+
+> After working with JSF for almost a year, trying Wicket was like that
+> movie scene where the clouds part and this big ray of light hits you
+> in the face. I just had this feeling while JSF'ing that certain things
+> were harder than they needed to be. Well, I was right, and the Wicket
+> people figured it out.
+>
+> [Kevin Galligan](http://bigheadco.blogspot.com/2007/03/groovy-wicket.html)
+
+> Wicket (currently undergoing incubation with Apache) is a good
+> example of a web framework which throws caution to the wind, and has
+> absolutely no XML needed. We here at Mystic have a lot of love for
+> Wicket and are actively developing several projects with it currently.
+>
+> [Mystic
Coders](http://www.mysticcoders.com/blog/2007/03/13/the-rise-of-the-xml-backlash/)
+
+
+> Writing a Wicket app is rather more like writing an event-based
+> desktop application than a web application.
+>
+> [LShift](http://www.lshift.net/blog/2006/07/06/wicket)
+
+> "Wickedly Cool" - I actually managed to whip together a Wicket
+> Application in a few days. It is entertaining to work with, adding
+> shiny stuff is really easy while you can develop Java code and keep
+> those last bits of hair you have saved for ripping out in a CSS
+> nightmare that you hopefully after finding Wicket will not have to
+> deal with. So I'd go out on a limb and say that Wicket == Rogaine for
+> developers.
+>
+> [Joed](http://blogs.opennms.org/joed/?p=3)
+
+> "So is Wicket the one true MVC framework that a lot of us have been
+> hunting for? At the moment, I tend to think so. [...] If you like Java
+> you will really like Wicket."
+>
+> [Peter
Thomas](http://ptrthomas.wordpress.com/2007/03/02/wicket-impressions-moving-from-spring-mvc-webflow/)
+
+> "I think its an awesome way to deal with this whole web UI framework
+> mess. I am happy to see someone take a simple and clean approach to
+> the whole problem, and come up with a transparent POJO solution. I
+> like the direction the framework is going... Wicket is clean, simple
+> and elegant."
+>
+> Comment on TheServerSide.com
+
+> "Last week I wrote an article about Wicket and I spent some time
+> discovering and taming it. And I have to confess this: I love it. ...
+> snip ... Wicket is not a framework, it's a candy bar. And everybody
+> loves candy bars..."
+>
+> Comment made by Romain Guy
+
+> The issue that impressed me in the Wicket model is that "Wicket does
+> not mix markup with Java code and adds no special syntax to your
+> markup files." You reference Wicket identities as HTML attributes
+> and define component properties in Java, which allows designers and
+> programmers to work independently (within the obvious constraint of
+> having common goals). There is no need for special tools.
+>
+> From a Network World editorial entitled "Nothing Sticky about Wicket"
+
+> In a recent blog post I asked for feedback on what Web frameworks
+> folks are using. Well, I got quite a surprise: Wicket was the most
+> often recommended framework in reader emails!
+>
+> From an About.com article entitled And the Winner is...Wicket
+
+> "I have used Wicket since last Fall for personal projects. I have 3
+> kids and a wife so my free-time is very limited. Given that, I had to
+> be very picky about which framework I chose. I've been very impressed
+> with how little hassle it has been to start creating powerful,
+> reusable components and pages with Wicket even under rather severe
+> time constraints."
+>
+> Comment on TheServerSide.com
+
+> "...after using web MVC frameworks for a couple of years, building
+> ever more complex web applications, I moved to component based
+> frameworks. Of these, I think Wicket is by far the best..."
+>
+> Comment on Manageability.org
+
+> "... Talk about a mind blowing experience, it literally took me ten
+> minutes to have a sample application up and running! The Wicket API is
+> very Swing like, which was a welcome change for me, and allowed for a
+> very familiar development experience. There is even an extension that
+> allows for direct use of a Swing TreeModel. There are so many things
+> that I like about this framework ..."
+>
+> From a blog item by the Code Poet
+
+> "Wicket has a learning flat."
+>
+> Al Maw
+
+> JSF is Cool and young but Wicket is younger and even cooler. Have
+> you tried wicket?. I am also building a large CRUD application for
+> Job Exchange System in my country using Wicket + JPA + Stateless
+> EJB3 + Glassfish (the latest promoted build of glassfish) and we are
+> currently in testing phase and I am not having any serious headaches
+> as things seems to be under control. All our forms are Ajax. We have
+> several concurrent accesses and system is stable. I believe greatly in
+> the Wicket Project especially for CRUD cases.
+>
+> [Dabar Aladejebi](http://www.javalobby.org/java/forums/t90719.html#92132195)
+
+> "focuses the development efforts in the right place, inside plain Java
+> code" !! This was the winning ticket for me. The framework is truly
+> amazing. I used ever dang framework in the book and can say that I'm
+> most impressed with this one.
+>
+> [Anonymous on
JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html)--
[Anonymous on
JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html)
+
+> Shocking simplicity. Back to the roots. Thanks.
+>
+> [joozsa on
JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html)
+
+> Wicket as far as I am concerned is the way forward for web development
+> in Java. A lot of creativity involved though especially with the loops
+> but It makes Web Development so much fun.
+>
+> [Anonymous on
JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html)
+
+> "Wicket became my favorite framework in about a 24-hour period, and
+> I think it has a very bright future. With most frameworks I see
+> limitations, with Wicket I see possibilities. There's your platitude
+> for the day :)"
+>
+> wicket-user mailing list
+
+> "Count me in... I've only been using Wicket for maybe 2 weeks or so,
+> and I'm sold."
+>
+> Phillip Rhodes
+
+> Once I grasped the essence of Wicket, everything just started working
+> so well. Damn you, Wicket, I said under my breath. I was really
+> disappointed that I liked it so much. Damn you Wicket! Suddenly I
+> loved all those Wicket developers, because I understood what they
+> were trying to say. Web development can be simple, yet have unlimited
+> power.
+>
+> Closet Wicket lover
Added: wicket/common/site/trunk/meet/features.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/meet/features.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/meet/features.md (added)
+++ wicket/common/site/trunk/meet/features.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,119 @@
+---
+layout: default
+title: Features
+---
+## Swing-like OO Component Model
+
+Pages and Components in Wicket are real Java objects that support
+encapsulation, inheritance and events.
+
+## Ease of Development
+
+Because Wicket is Java and HTML, you can leverage what you know about Java or
+your favorite HTML editor to write Wicket applications.
+
+## Separation of Concerns
+
+Wicket does not mix markup with Java code and adds no special syntax to your
+markup files. The worlds of HTML and Java are parallel and associated only by
+Wicket ids, which are attributes in HTML and Component properties in Java.
+Since Wicket HTML is just HTML and Wicket Java is just Java, coders and
+designers can work independently to a large degree and without relying on any
+special tools.
+
+## Secure
+
+Wicket is secure by default. URLs do not expose sensitive information and all
+component paths are session-relative. Explicit steps must be taken to share
+information between sessions. There are plans for the next version of Wicket
+to add URL encryption to support highly secure web sites.
+
+## Transparent, Scalable Clustering Support
+
+All Wicket applications will work on a cluster automatically and without
+additional work. Once bottlenecks are understood, Wicket enables tuning of
+page state replication. The next version of Wicket will support client-side
+models for zero-state scalability.
+
+## Transparent Back Button Support
+
+Wicket supports configurable page version management. When users submit a
+form or follow a link from a page they accessed with the back button in their
+browser, Wicket is able to revert the page object to the state it was in when
+the page was originally rendered. This means you can write web applications
+that support the back button with very little work.
+
+## Reusable Components
+
+Reusable components in Wicket are particularly easy to create. Not only can
+you extend existing components with the Java extends keyword, but you can
+also create Panel components which associate a group of components as a
+reusable unit.
+
+## Simple, Flexible, Localizable Form Validation
+
+It is trivial to write and use validators in Wicket. It is also quite easy to
+customize and localize the display and content of validation error messages.
+
+## Typesafe Sessions
+
+Wicket eliminates the need to manage HttpSession attributes by hand. Page and
+component objects are transparently stored in the session and your
+application can create a custom session subclass with typesafe properties as
+well. All objects stored in the session can automatically participate in
+clustering replication.
+
+## Factory Customizable
+
+Wicket is very extensible. Most operations are customizable through factories
+or factory methods.
+
+## Detachable Models
+
+Model objects in Wicket can be very lightweight in terms of memory and
+network use in a cluster. When a model is used, it can "attach", populating
+itself with information from persistent storage. When the model is no longer
+in use, transient information can be reset, reducing the size of the object.
+
+## Border Components
+
+Wicket Border components enable the decoration of pages in a reusable
+fashion. This is especially useful for inheritance of common navigational
+structures or layout.
+
+## Support for All Basic HTML Features
+
+Wicket supports image tags, links, forms and everything else that you're used
+to using in your web application development.
+
+## Programmatic Manipulation of Attributes
+
+Wicket Components can programmatically change any HTML tag attribute.
+
+## Automatic Conversions
+
+Once a Form validates, the model can be updated using Wicket converters. Most
+ordinary conversions are built-in and it is easy to write new converters.
+
+## Dynamic Images
+
+Wicket makes image use, sharing and generation very easy. Dynamic images can
+be created by simply implementing a paint method.
+
+## Pageable ListView
+
+ListViews in Wicket are extremely powerful. You can nest any kind of
+component in a ListView row, even other ListViews. PageableListView supports
+navigation links for large lists.
+
+## Tree Component
+
+Out of the box tree component for navigating and selecting nodes.
+
+## Localization
+
+HTML pages, images and resource strings can all be localized.
+
+## Examples
+
+Wicket has numerous examples showcasing all of the above features.
Added: wicket/common/site/trunk/meet/index.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/meet/index.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/meet/index.md (added)
+++ wicket/common/site/trunk/meet/index.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,4 @@
+---
+layout: default
+title: Meet Apache Wicket
+---
Added: wicket/common/site/trunk/meet/introduction.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/meet/introduction.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/meet/introduction.md (added)
+++ wicket/common/site/trunk/meet/introduction.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,296 @@
+---
+layout: default
+title: Meet Apache Wicket
+---
+By Jonathan Locke, original author of Wicket
+
+## Why Wicket?
+
+If you are looking to do web application programming in Java, you have a very
+large number of choices these days. In fact, there are so many web
+application frameworks now that it has become somewhat of a joke. One blog
+site on the Internet poses the question: How many Java web frameworks can you
+name? The answer they show looks like this:
+
+## Frameworks, Frameworks Everywhere
+
+<TABLE class="confluenceTable"><TBODY>
+<TR>
+<TD class="confluenceTd">Echo</TD>
+<TD class="confluenceTd">Cocoon</TD>
+<TD class="confluenceTd">Millstone</TD>
+<TD class="confluenceTd">OXF</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Struts</TD>
+<TD class="confluenceTd">SOFIA</TD>
+<TD class="confluenceTd">Tapestry</TD>
+<TD class="confluenceTd">WebWork</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">RIFE</TD>
+<TD class="confluenceTd">Spring MVC</TD>
+<TD class="confluenceTd">Canyamo</TD>
+<TD class="confluenceTd">Maverick</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">JPublish</TD>
+<TD class="confluenceTd">JATO</TD>
+<TD class="confluenceTd">Folium</TD>
+<TD class="confluenceTd">Jucas</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Verge</TD>
+<TD class="confluenceTd">Niggle</TD>
+<TD class="confluenceTd">Bishop</TD>
+<TD class="confluenceTd">Barracuda</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Action Framework</TD>
+<TD class="confluenceTd">Shocks</TD>
+<TD class="confluenceTd">TeaServlet</TD>
+<TD class="confluenceTd">wingS</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Expresso</TD>
+<TD class="confluenceTd">Bento</TD>
+<TD class="confluenceTd">jStatemachine</TD>
+<TD class="confluenceTd">jZonic</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">OpenEmcee</TD>
+<TD class="confluenceTd">Turbine</TD>
+<TD class="confluenceTd">Scope</TD>
+<TD class="confluenceTd">Warfare</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">JWAA</TD>
+<TD class="confluenceTd">Jaffa</TD>
+<TD class="confluenceTd">Jacquard</TD>
+<TD class="confluenceTd">Macaw</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Smile</TD>
+<TD class="confluenceTd">MyFaces</TD>
+<TD class="confluenceTd">Chiba</TD>
+<TD class="confluenceTd">JBanana</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Jeenius</TD>
+<TD class="confluenceTd">JWarp</TD>
+<TD class="confluenceTd">Genie</TD>
+<TD class="confluenceTd">Melati</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Dovetail</TD>
+<TD class="confluenceTd">Cameleon</TD>
+<TD class="confluenceTd">JFormular</TD>
+<TD class="confluenceTd">Xoplon</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Japple</TD>
+<TD class="confluenceTd">Helma</TD>
+<TD class="confluenceTd">Dinamica</TD>
+<TD class="confluenceTd">WebOnSwing</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Nacho</TD>
+<TD class="confluenceTd">Cassandra</TD>
+<TD class="confluenceTd">Baritus</TD>
+<TD class="confluenceTd">Stripes</TD>
+</TR>
+<TR>
+<TD class="confluenceTd">Click</TD>
+<TD class="confluenceTd">GWT</TD>
+<TD class="confluenceTd"> </TD>
+<TD class="confluenceTd"> </TD>
+</TR>
+</TBODY></TABLE>
+
+
+## Why "Reinvent the Wheel"?
+
+In light of this, you may be wondering "What good is another web application
+framework?" Indeed. Why "re-invent the wheel?" One snappy comeback to that
+old saw is: because this time we could make it rounder!
+
+But it was not simply a desire for higher quality that drove the creation of
+Wicket. Even with so many options, there really is no web toolkit which fills
+exactly the niche that Wicket fills. In fact, Wicket is quite unlike each of
+the frameworks above.
+
+Wicket's closest cousins are probably Tapestry and Echo, but even there the
+likeness is very shallow. Like Tapestry, Wicket uses a special HTML attribute
+to denote components, enabling easy editing with ordinary HTML editors. Like
+Echo, Wicket has a first-class component model. But Wicket applications are
+not like applications written in either Tapestry or Echo, because in Wicket
+you get the best of both worlds. You get the benefits of a first-class
+component model and a non-intrusive approach to HTML. In many situations,
+this combination may prove to be a significant development advantage.
+
+To understand why Wicket is so different, it may help to understand the
+motivations that created it.
+
+## Motivations
+
+### Most existing web frameworks provide weak to non-existent support in
managing server-side state ###
+
+This normally means lots of ad-hoc code in web applications dealing with the
+gory mechanics of state management. While Wicket will not allow you to stop
+thinking about server state, it goes a long ways towards making it easy and
+often transparent to manage that state.
+
+In Wicket, all server side state is automatically managed. You will never
+directly use an HttpSession object or similar wrapper to store state.
+Instead, state is associated with components. Each server-side page component
+holds a nested hierarchy of stateful components, where each component's model
+is, in the end, a POJO (Plain Old Java Object). Wicket maintains a map of
+these pages in each user's session. One purpose of this page map (and the
+component hierarchy on each page) is to allow the framework to hide all
+details of how your components and models are accessed. You deal with simple,
+familiar Java objects and Wicket deals with things like URLs, session ids and
+GET/POST requests.
+
+You will also find that this well-structured server state makes it very easy
+to deal with the dreaded "back button problem". In fact, Wicket has a generic
+and robust solution which can identify and expire browser-cached pages that
+have become stale due to structural changes to the model of a component on
+the page.
+
+Finally, Wicket has been designed to work with POJO persistence frameworks
+such as JDO or Hibernate. This can make database driven web applications
+quite easy to write.
+
+For many applications, it will be worth trading off the increased server load
+of extra server-side state for decreased development costs, lower maintenance
+costs, quicker time-to-market and generally higher quality software. The
+basic observation here is that software is expensive and complex while
+servers from companies like E-machines and Dell are relatively dirt cheap.
+
+In terms of efficiency versus productivity, perhaps Wicket is to JSP as Java
+is to C. You can accomplish anything in Wicket in JSP. You may even do it
+more efficiently in terms of memory or processor consumption. But it may take
+you weeks or months longer to develop your application. And in the end, since
+state management in JSP is ad-hoc, you are likely find security problems and
+bugs popping up everywhere. Most of the other frameworks above will do only a
+little more to help you.
+
+### Most existing frameworks require special HTML code
+
+JSP is by far the worst offender, allowing the embedding of Java code
+directly in web pages, but to some degree almost all of the frameworks from
+the list (except Tapestry) above introduce some kind of special syntax to
+your HTML code.
+
+Special syntax is highly undesirable because it changes the nature of HTML
+from the kind of pure-and-simple HTML markup that web designers are familiar
+with, to some kind of special HTML. This special HTML can be more difficult
+to preview, edit and understand.
+
+Wicket does not introduce any special syntax to HTML. Instead, it extends
+HTML in a standards-compliant way via a Wicket namespace that is fully
+compliant with the XHTML standard. This means that you can use Macromedia
+Dreamweaver, Microsoft Front Page, Word, Adobe Go Live, or any other existing
+HTML editor to work on your web pages and Wicket components. To accomplish
+this, Wicket consistently uses a single id attribute in the Wicket namespace
+("wicket:id") to mark HTML tags that should receive special treatment by the
+toolkit. If you prefer not to render Wicket namespaced tags and attributes to
+your end-users, Wicket has a simple setting to strip them all out, resulting
+in ordinary, standards-compliant HTML.
+
+No "special sauce" in your HTML means designers can mock up pages that you
+can use directly in development. Adding Java components to the HTML is as
+simple as setting the component name attribute. And you can then give the
+HTML back to your web designers knowing that they can change it with
+confidence.
+
+Wicket, more than any other framework gives you a separation of concerns. Web
+designers can work on the HTML with very little knowledge of the application
+code (they cannot remove the component name tags and they cannot arbitrarily
+change the nesting of components, but anything else goes). Likewise, coders
+can work on the Java components that attach to the HTML without concerning
+themselves with what a given page looks like. By not stepping on each other's
+toes, everyone can get more work done.
+
+### Existing frameworks are not easy
+
+Most of the existing toolkits have poorly defined or non-existent object
+models. In some cases, the model is defined using special XML syntaxes. The
+syntaxes may be so cumbersome that special tools are required to manipulate
+all the configuration information. Since these toolkits are not simple Java
+libraries you may or may not be able to use your favorite IDE tools such as
+editors, debuggers and compilers.
+
+Wicket is all about simplicity. There are no configuration files to learn in
+Wicket. Wicket is a simple class library with a consistent approach to
+component structure. In Wicket, your web applications will more closely
+resemble a Swing application than a JSP application. If you know Java (and
+especially if you know Swing), you already know a lot about Wicket.
+
+### Existing frameworks inhibit reusability
+
+Tapestry and JSF at least have component models that allow reuse, but you are
+likely to find that it is not particularly trivial to do, at least when
+compared with Wicket. Wicket has been explicitly designed to make it very,
+very easy to create reusable components. It's surprisingly simple to extend
+existing components and to make compound components such as a SignInPanel or
+AddressForm. It is also relatively easy to create components that exploit new
+features of browsers. Components in Wicket can be packaged up in JAR files
+and reused by simply dropping them in your lib folder - no configuration
+necessary!
+
+### Web programming should be fun!
+
+This is my most personal goal for writing Wicket . None of the existing
+frameworks are appealing to me in terms of intuitiveness, quickness, ease of
+development, etc. It is my hope that Wicket represents a significant step in
+the direction of making web applications easy and fun to write.
+
+## Goals
+
+Coming from these motivations, the following goals for Wicket emerged:
+
+* EASY (SIMPLE / CONSISTENT / OBVIOUS)
+ * POJO-centric
+ * All code written in Java ala Swing
+ * Minimize "conceptual surface area"
+ * Avoid overuse of XML configuration files
+ * Fully solve back button problem
+ * Easy to create bookmarkable pages
+ * Maximum type safety and compile-time problem diagnosis
+ * Maximum diagnosis of run-time problems
+ * Minimum reliance on special tools
+ * Components, containers and conventions should be consistent
+
+* REUSABLE
+ * Components written in Wicket should be fully reusable
+ * Reusable components should be easily distributed in ordinary JAR files
+
+* NON-INTRUSIVE
+ * HTML or other markup not polluted with programming semantics
+ * Only one simple tagging construct in markup
+ * Compatible with any ordinary HTML editor
+ * Easy for graphics designers to recognize and avoid framework tagging
+ * Easy to add tagging back to HTML if designers accidentally remove it
+
+* SAFE
+ * Code is secure by default
+ * Only explicitly bookmarkable links can expose state in the page or URL
+ * All logic in Java with maximum type safety
+ * Easy to integrate with Java security
+
+* EFFICIENT / SCALABLE
+ * Efficient and lightweight, but not at the expense of other goals
+ * Clustering through sticky sessions preferred
+ * Clustering via session replication is easy to accomplish and easy to tune
by working with detachable models.
+
+* COMPLETE
+
+ * The Wicket team is committed to deliver a feature complete, ready-to-use
+ framework for developing Java web applications. The core framework was
+ written and contributed by the author of this introduction, Jonathan
+ Locke. The current team consists of a group of experienced programmers,
+ some of which were active on some of the other frameworks stated above,
+ and all of which have extensive experience building large scale Java web
+ applications. We eat our own dogfood, and will thus work on Wicket from a
+ framework user's perspective.
Added: wicket/common/site/trunk/meet/vision.md
URL:
http://svn.apache.org/viewvc/wicket/common/site/trunk/meet/vision.md?rev=965997&view=auto
==============================================================================
--- wicket/common/site/trunk/meet/vision.md (added)
+++ wicket/common/site/trunk/meet/vision.md Tue Jul 20 20:40:53 2010
@@ -0,0 +1,60 @@
+---
+layout: default
+title: The Wicket Vision
+---
+
+Designing and implementing any framework for use in the real world inevitably
+involves compromises and some degree of complexity, and Wicket is no
+exception. However, I believe you will find that Wicket is quite compact,
+focused and powerful as a framework. If Wicket has these characteristics, it
+is because it was designed to solve one very specific problem well:
+
+> enabling component-oriented, programmatic manipulation of markup
+
+Wicket does this and very little else, and that is a good thing.
+
+I once heard Josh Bloch talk about the power to weight ratio of an API. The
+highest compliment anyone could make of Wicket would be to suggest that
+Wicket has a lot of power and not much conceptual surface area.
+
+In art, negative space is the part that's not the subject. In music, negative
+space is the rest. In software, negative space is all the code that you
+managed to avoid writing. In all three disciplines, it's what separates what
+is truly excellent from what is merely good.
+
+Following this metaphor, if Wicket is our foreground object, it is defined in
+a negative sense by all the things that it is not (by the background).
+
+In other words, ideally, Wicket is a web UI framework that delegates as many
+areas of responsibility as possible to other, more focused tools and
+techniques. It recognizes that Hibernate is good at persistence; that OGNL is
+good at string formatting; that Java properties files are good for
+localization; that sub-classing is good for creating component types; that
+Dreamweaver is good at doing HTML layout; that Beans are good for structuring
+properties; and so on.
+
+The more ways that Wicket can find to offload responsibilities (both now and
+in the future), the less it will be. And thus, the more it will be.
+
+The difficulty moving forward with Wicket will be balancing all the
+day-to-day needs people are going to be bringing up with this overall vision
+of minimalism. There ultimately will be compromises, and the "trick" to
+making the right compromises is simply to agonize over all the options for a
+long time and then to only make the compromises that everyone agrees are
+really essential to what Wicket needs to be and do.
+
+A big part of this process of agonizing is to act like doctors and "first, do
+no harm". If some issue isn't sitting well with everyone yet, there's
+probably a reason for that. So, maybe the near-term solution is to simply do
+nothing and let people use the existing functionality until the limits to
+that approach (as well as competing ideas) are better understood.
+
+It's easy to add features. It's often impossible to change or remove them.
+
+Given this, the Wicket approach to the overall problem of evolving while
+keeping a high power to weight ratio will be partitioning off all
+controversial new ideas in a "contrib" package until they are broadly
+accepted. This way people can experiment and code away and check in lots of
+stuff without affecting the main codebase with untested ideas. Then, when
+ideas in contrib pan out to everyone's satisfaction, the lead(s) of the
+project will move them into the core.
\ No newline at end of file
