Free IT Books, Study Guides, Practice Exams, Tutorials and Software
Friday, October 31st 2014
-  Free Books
Free MSDN Mags
Free Oracle Mags
Free software CDs
- Certifications
  Exam Details
  Mock exams
  Study guides
  Exam Details
  Mock exams
  Study guides
  Sample chapters
  Exam Details
  Mock exams
  Study guides
  Sample chapters
  Exam Details
  Mock exams
  Study guides
  Sample chapters
  Exam Details
  Mock exams
  Study guides
  Sample chapters
  Exam Details
  Mock exams
  Study guides
  Sample chapters
  Mock exams
  MCSE guides/exams
  Exam Resources
- Java / J2EE
- .NET
Knowledge Base
  .NET Framework
  Visual Studio.NET
- About
Gayan Balasooriya

Broken links?
Suggest good links
To remove links
 weblogs from Javablogs.com

JSF 2.3 changes

The following spec issues were addressed

#1333 - Support @Inject for UIViewRoot
#1332 - Let CDI handle #{view}
#1331 - Let CDI handle #{application}

And the following other issues that have a 2.3 impact were addressed

#3425 - Apply Java SE 7 Strings in switch
#3427 - Apply Java SE 7 multi-catch
#3444 - Apply Java SE 7 multi-catch: part 3 of 3
#3443 - Apply Java SE 7 multi-catch: part 2 of 3
#3427 - Apply Java SE 7 multi-catch: part 1 of 3
#3441 - Apply Java SE 7 multi-catch: javax.faces-api
#3501 - Unable to locate BeanManager with Weld on plain Tomcat (Thanks Neil)


JSF 2.3 Injecting the UIViewRoot

And now you can inject the UIViewRoot

In code

UIViewRoot viewRoot;


JavaOne 2014 Day Four Notes

With all of my formal JavaOne conference obligations satisfied, day four was dedicated to listening. Another day, another hotel. The community keynote had a little bit of everything and was in the San Francisco Marriott, bringing to four the total number of separate buildings I had to visit for JavaOne. The complete keynote is available at Oracle. The room was full, and Intel VP Michael Greene had an attentive audience for his portion of the keynote. The keynote quickly moved on to showcasing some highlights from the Java community over the last year. There was a great selection of awards, demos, and product announcements. I was happy to see Scratch style programming return to the Java platform in the form of SnapCode, demonstrated by its creator Jeff Martin. I feel that Scratch is the gold standard in this sort of environment, and I was very disappointed when they dropped Java in favor of Flash (as part of a broader move to an entirely cloud-based development environment, which I also didn't appreciate). If you had some of the same reservations, consider giving SnapCode a try. There were some other nifty demos all of which combined to give the attendees a positive impression about how fun and cool it is to develop on the Java Platform.

Mark Reinhold re-appeared and gave the rest of the technical keynote, allowing Brian Goetz to finish his interrupted content from Sunday. Oracle has helpfully produced a single streaming file with the content from both days. Mark and Brian's presentation was followed by a question and answer panel, facilitated by the twitter hashtag #j1qa and adding James Gosling, Brian Oliver and Charles Nutter as panelists. Perhaps we should have done this approach during the web framework smackdown. The most humorous question was regarding a suggestion to move OpenJDK to GitHub. Mark's satisfyingly definitive answer was "no". As usual with large-scale Q&A panels, there was not much depth and the questions bounced around a lot. It's always great to have James Gosling on hand for some part of JavaOne, and this year he pointed out that Java has come full circle, having been intended for "Internet of Things" from the start. I'll point out that Sun had a mass-market IoT device ten years ago in theform of the SunSPOT. Did you know that Oracle Labs continues the work on SunSPOT and you can still buy them for $399? The panel closed out with the traditional t-shirt cannon distribution. I give a special thanks to my old pal Vinicius Senger for catching one for me. In a nod to a more TED-style talk, (but a mere shadow of the glory days of Douglas Adams' JavaOne keynote) Andra Keay gave a nice talk about the dynamics of robot/human interactions. Sadly missing from the talk was any mention about my pet peeve in the whole robot revolution: the need to change how society values the output of human work in a world where robots do most of the work.

The conference orgnizers thoughtfully delayed the start of the rest of the sessions by 30 minutes to accomodate the lengthened keynote. This gave me time to get back over to Parc55 for CON2131: Java EE Community Update and Panel. Bruno Borges moderated. On the panel were my (skiplevels) boss Cameron Purdy, John Clingan, GlassFish Product Manager at Oracle, Kevin Sutter, Java EE Architect at IBM, Mark Little, RedHat VP, Adam Bien, famous Java EE consultant, and David Blevins founder of Tomitribe. Sadly missing from this year's panel was any representative from Pivotal. Bruno lead off the session with some slides and allowed the panelists to introduce themselves. Interestingly, the slides in the content catalog for this session are Mark Little's, not Bruno's. Nonetheless, Mark's slides are very informative, do check them out. The discussion rapidly focused on some current trends in enterprise Java software and how Java EE has responded to and will respond to these trends. Mark Little, in typical dry British fashion, observed that what we now call microservices is really just the latest name for SOA. This observation lead to an acknowledgement that the idea of a WAR file being deployed in a container is starting to give way to the idea of a deployable application that contains an executable runtime. I hope they post the audio for this session because there was a lot more that I'm not recalling.

It turned out that the next session I attended was the only purely technical Java EE based session I could make, but it was a good one. It was CON3389: Migrating a JSF-Based Web application from Spring 3 to Java EE 7 and CDI. The slides are in the content catalog. This session by Leander Reimer was an excellent case-study of how an existing JSF based web application that was built on Spring was migrated to a pure Java EE stack. It is common knowledge that Spring has risen to prominence by positioning itself as an alternative to Java EE. What is not so common knowledge is that there has always been significant interplay and cross-polination of ideas between Spring and Java EE. For example, did you know that JSF 1.0 had its own, XML based dependency injection mechanism way back in 2004, right around the time that Spring 1.0 was released? This sort of thing is not surprising since both stacks have been trying to solve the same kinds of problems, for the same kinds of developers, and there are only so many ways to skin a cat. This fact enabled Mr. Reimer and his team to successfully and quickly complete the migration. The main idea of the talk was to show that for every thing they had in their app using Spring, there was a corresponding way to do it in Java EE. This traversal of migration tasks served as a vehicle for pointing out several pitfalls they had to safely navigate to get to production. During the Q&A I asked Mr. Reimer a two part question. First, I asked why did they use JSF in the first place when many Spring shops just go with the built-in Spring MVC? His answer: PrimeFaces. Next, I asked him to speculate how much harder would the task have been had the UI been in Spring MVC instead of JSF. I was hoping the discussion might give my colleague Manfred Riem, also in the audience, a chance to bring up MVC 1.0. Instead, Mr. Reimer observed it wouldn't be that hard to write an integration layer on top of JSF that allows its use in an action-oriented manner. This was a skillfully executed talk with a compelling topic given from an in-the-trenches perspective. Bravo.

Way back in March when I attended JavaLand I saw an excellent session from my old pals Manfred Geiler and Thomas Spiegl from Irian. The session was about their new UI technology called Ankor. I requested they submit this session to JavaOne, and thankfully it was accepted as CON2403 - Reactive UIs with the MVVM Pattern. Ed Burns and Manfred GeilerEd Burns and Manfred GeilerI was unable to attend the talk as it conflicted with Mr. Reimer's but I did catch up with Manfred and Thomas after their session for a beer in Duke's cafe. This was a special anniversary for Manfred and I. Ten years ago, at JavaOne 2004, Manfred and I met when he attended my session on JSF 1.0. Manfred approached me and said, "Hey, I have an independent implementation of JSF," and I was thrilled. This, of course, was MyFaces. To commemorate these two meetings separated by ten years, at left you see Manfred and I at JavaOne 2004, and at right, with Thomas Spiegl, at JavaOne 2014.

My final session, in the final slot, was Mike Duigou's excellent CON6309 New Tricks for Old Dogs: Collections in Java 8. The slides haven't been posted yet, but do get them when they become available. Talks like this are really useful to expose you to the new features you really need in practice. Mike's session was really useful because he gave the perspective behind the design choices in these fundamental library classes that have contributed so much to the success of Java over the years. Sadly, I see that Mike has recently left Oracle but he's now working with James Gosling directly at his Liquid Robotics outfit. I wish you the best, Mike, but I'm sure we'll see you at JavaOne next year. I ran into Stuart Marks after Mike's session and he gave me a checkup on the knowledge I had absorbed, as seen at left.

To sum up JavaOne 2014, Oracle's consistent investment in promoting the Java Developer community is very evident. Though firmly in legacy territory, Java is still very vibrant and very new. The priorities behind the design choices in Java itself (innovation packaged in an enterprise ready programming environment) are on display in the community as well.

JSF 2.3 allow CDI to handle #{application}

Nothing really fancy, but #{application} EL resolving is now done using a 2.3 CDI producer.

Note there won't be @Inject support for this as it is not referring to a specific typed artifact.


JSF 2.3 changes

While it looks like not a whole lot has been going on issue wise some additional work not covered by specification issues has be done

a) Javadoc cleanup for JavaSE 8
b) Apply diamond operator to sources

And the following specification issues were handled:

#1254 - contracts attribute too restrictive.
#1328 - Let CDI handle #{session} EL resolving
#1327 - Verify @Inject HttpSession support


Soft Skills: Being a professional from Soft Skills by John Sonmez

Soft Skills

Save 42% on Soft Skills: The software developer's life manual with discount code ssjnet14 at manning.com.

[This article excerpted from Soft Skills: The software developer's life manual.]

In one of my favorite books of all time, The War of Art, Steven Pressfield expounds upon the difference between being a professional and being an amateur:

Turning pro is a mindset. If we are struggling with fear, self-sabotage, procrastination, self-doubt, etc., the problem is, we’re thinking like amateurs. Amateurs don't show up. Amateurs crap out. Amateurs let adversity defeat them. The pro thinks differently. He shows up, he does his work, he keeps on truckin’, no matter what.

Being a professional is all about showing up, doing your work, and not letting adversity defeat you. Being a professional requires you to overcome your vices so that you can sit down and produce the best work possible.

In this article we’re going to focus on what it means to be a professional and how you can be a professional in your software development job whether you work for someone else directly or produce work for clients.

As a software developer, professionalism will be one of your greatest assets. Not only will learning how to act like and be perceived as a professional help you to get better jobs and more clients, but it will also help you feel better about the kind of work you’re doing and to have pride in that work—a critical component of long-term success.

What is a professional?

Simply put, a professional is someone who takes their responsibilities and career seriously and is willing to make the tough choices that have to be made—often at their own expense—for the purpose of doing what they know is right.

For example, imagine what you’d do in a situation where you’ve been asked to cut your normal quality standards and just ship some code as quickly as possible. How do you react in this situation? What if you’re repeatedly asked to work in this way? Can you stand up and do what is right, even if it may end up costing you your job? What principles do you stand for? What quality bar do you personally set on your work?

A professional is what we should all strive to be. A professional is someone you can count on to get a job done and to do it right, but a professional also doesn’t just tell you what you want to hear (see Table 1). A professional will let you know when something isn’t possible or the path you want to proceed down is wrong.

A professional is someone who may not have all the answers, but thoroughly studies his or her craft and seeks to hone his or her skills. A professional will freely admit when he or she doesn’t know the answer, but you can count on a professional to find it.

Perhaps most importantly, a professional is consistent—stable. A professional has a high-quality standard for his or her work and you can expect a professional to adhere to it each and every day. When a professional doesn’t show up, you had better call emergency dispatch, because there is certainly something wrong.

Table 1 Professionals versus amateurs

Professionals Amateurs
Has principles that they abide by Does whatever is asked
Is focused on getting the job done right Is focused on getting the job done
Isn’t afraid to admit when they are wrong or don’t know Pretends to have knowledge they don’t possess
Consistent and stable Unpredictable and unreliable
Takes responsibility Avoids responsibility

Being a professional (forming good habits)

It’s easy to identify a professional, but how do you become one? What is it about you and your work that reeks amateur, and how do you neutralize the odor?

It starts with habits. Habits are an essential part of becoming a professional, because a large portion of what we do every day is completely habitual. We get up, we go to work, and we perform our daily routines each and every day, mostly without really thinking about it. If you want to change your life, you need to start with changing your habits. This is, of course, easier said than done. Bad habits are exceedingly difficult to break and new habits aren’t easy to form.

But, if you want to become a professional, you need to develop the habits of a professional. At one time when I was working on a team following the Scrum process, where we would have a daily stand-up meeting stating what we had done, what we had planned to do, and what was impeding us, there was one developer in particular who always had a written version of exactly what he was going to say. Every single day before the Scrum meeting he would prepare his statement, instead of coming up with it during the meeting like most of us did. This is the kind of habit a professional develops.

Another strong habit to develop as a professional is time-management skills. How good are you at managing your time right now? Do you know what you’re going to work on each day before you work on it? Do you have a good handle on how long routine tasks will take? Get in the habit of effectively managing your time by planning out your day in advance. A professional knows what work must be done each day and knows roughly how long it will take to do the work.

These are just two examples of the kinds of habits that are important to develop as a professional software developer. You’ll have to decide for yourself what habit you need to form to reach your own standard of professionalism in your work, but habits are critical because habits build consistency and consistency is what makes you reliable. (For a great book on the subject of habits, check out The Power of Habit by Charles Duhigg.)

Doing what is right

As a software developer you’re often faced with many difficult challenges, both technical and ethical. If you want to be a professional, you need to be able to make the correct choices in both of these cases. Often the technical challenges you face are more objective. There are right ways to solve technical problems. It’s easy to prove one solution over another. But the ethical challenges can be much more difficult. There isn’t always a clear-cut right answer.

One of the biggest ethical challenges software developers face is that of going forward with decisions they know are correct and in the best interest of their client even if making those decisions could jeopardize their own well-being or stability.

One of my favorite software developers and authors, Bob Martin, wrote an excellent article on saying “no,” which addresses this very issue. In the article, Bob compares a software developer to a doctor. He talks about how absurd it would be for a patient to tell a doctor how to do his or her job. In his example, a patient tells the doctor that his arm hurts and that he needs to cut it off. Of course the doctor says “no” in this case. But in many cases software developers in a similar situation, fearing the wrath of higher-ups, will say “yes” and perform an amputation on their code.

A professional needs to know when to say “no,” even to his or her own employers, because, as Bob put it, professionals have certain lines they won’t cross. It might even mean getting fired, but sometimes that is the price to pay if you want to call yourself a professional. In the short term, it may be painful, but consistently choosing to do the thing you know is right over the course of your career is much more likely to pay off than the alternative—plus you can sleep better at night.

Sometimes professionals have to make tough decisions about the priorities of what they work on. Unprofessional developers will often waste time by gold-plating things, because they can’t decide what to work on next or they’ll constantly have to ask someone else to set their priorities. A professional assesses the work that has to be done, prioritizes it, and gets to work.

Landmine: What if I can’t afford to say “no”?

It’s pretty easy for me to sit back in my chair and tell you that you just have to say “no” sometimes, but not everyone has the luxury of being able to risk their job. I understand that you may be in a position where you literally can’t say “no,” because doing so could be catastrophic for you future.

My advice in this situation is to go ahead and do what you need to do to get by, but never let yourself get in this kind of situation again. It’s easy to get trapped into situations where you need a job, but when you get trapped in those situations you really limit your own options and allow people to exercise great power over you.

If you’re in this kind of a situation, try to get out of it as fast as possible. Save up some money so that you don’t have to worry so much about losing your job. You might even consider looking for another job where you won’t be required to make so many ethical decisions or where your opinion is more highly valued.
When it comes down to it, you have to do what you have to do, but always try to put yourself in positions where you have the upper-hand or are at least on equal footing, whenever possible.

Seeking quality and self-improvement

As a professional you must strive to constantly be improving and increasing the quality of the work you produce. You won’t always be able to produce the quality of work you desire, but over time, with consistency, you’ll reach your standards. The big mistake many software developers make is to lower their standards when they seem out of reach instead of seeking to improve themselves to rise up to meet the challenge.

It’s important to apply quality to every detail of your work, not just the parts that seem most important. A real professional has high-quality standards for all areas of his or her work, because a professional knows that, as T. Harv Ekr put it, “how you do anything is how you do everything.” If you lower your standards in one area, you’ll inadvertently find them dropping in other areas as well. Once you’ve crossed the line of compromise it can be difficult to go back.

And don’t forget to play to your strengths. You can, of course, improve your weaknesses, but it’s a good idea to know what your individual strengths are and use them to your advantage. A professional has a good, accurate, and realistic self-assessment of his or her own abilities—and weaknesses.

The way a professional meets the high-quality expectations he or she has is by continuous self-improvement. If you want to be a professional, you need to dedicate yourself to always improving your skills and learning more about your craft. Make sure that you have an education plan that you can follow to expand your skills and learn new things that will help you do your job better. Don’t ever be happy with good enough—always strive to become a better version of yourself.

Taking action

Would you define yourself as a professional today? If so, why? If not, why not?

  • What are your habits? Observe your day and try to identify as many habits as possible. List your habits in two categories, good and bad. Now identify some good habits you need to develop. Come up with a plan for developing those habits.
  • When was the last time you had to say “no”? If you’ve never encountered this situation, think about what you'd do if your boss asked you to do something that you knew was wrong. How would you react?
    • For more, check out Soft Skills: The software developer's life manual.

      Getting to Know the Oracle Developer Cloud Service

      Oracle Developer Cloud Service is included as a free entitlement with Oracle Java Cloud Service and Oracle Messaging Cloud Service. The Developer Cloud Service includes all the tools you need to support the team development lifecycle. There are popular open source tools such as Git, Maven and Hudson. There's also task management, code reviews and a wiki.

      The easiest way to experience the Oracle Developer Cloud Service is through a trial of the Oracle Java Cloud Service - SaaS Extension (click the "Try It" button).

      Try It!

      In this article I will introduce the Developer Cloud Service by using Maven to create a new web application, Git to manage the application source and Hudson to build and deploy my application to the Java Cloud Service.


      If you plan to follow along, this tutorial also assumes you already have Maven and Git installed. I will be using the Git Console from my desktop to interface with the Developer Cloud Service. The tutorial also assumes, of course, that you have access to the Developer Cloud Service!

      Create a New Project

      As a first step, log into the Developer Cloud Service and create a new project.

      All Projects

      Give the project a Name, Description and select the Privacy setting (for team projects you should select Organization Private):

      Create Project Name

      For this example, we will not be using a template:

      Create Project - Template

      And finally, chose the Wiki markup style you prefer and click Create Project to begin:

      Create Project - Properties

      As the project is being created, you can watch as the services are being provisioned for you. This should only take a couple of seconds:

      Service Provisioning

      Soon, project service provisioning is complete and you're ready to start using your new project:


      Develop an Application

      Here we'll use Maven to quickly create a web application. I'm going to do this from the Git Console so I'll have a consistent local user interface throughout this tutorial. This is the Maven command I'll be running, which creates a fully functional Hello World web application:

      mvn archetype:generate -DgroupId=HelloDeveloperCloudService -DartifactId=HelloDeveloperCloudService -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

      mvn generate

      Let's now put the application under source control management.

      Git SCM

      We begin by creating a Git repository for our web application. If you're not already familiar with Git, their Try Git tutorial provides an excellent introduction.

      Change into the newly created application directory and run:

       git init


      Next we need to add the files to the repository index and stage them for commit:

      git add .

      git add

      Now commit the new files to the local repository.

      git commit -m "Add initial webapp files"

      git commit

      Now we need to add our remote repository (the one in the Developer Cloud) to Git. For this you'll need to copy the Git source code repository URL from your Developer Cloud Service project. 'dcs' is the name we will use to refer to this repository going forward:

      git remote add dcs {copy https URL from Developer Cloud Service project}

      git remote add

      Now push our web application project files to the Developer Cloud Service. The name of our remote is 'dcs' and the default local branch name is 'master'. The -u tells Git to remember the parameters, so that next time we can simply run git push and Git will know what to do.

      git push -u dcs master 

      At this point you'll also be prompted for your Developer Cloud Service password:

      git push


      Now that our source code is in the Oracle Cloud, we can run a Hudson build Job. The Developer Cloud Service comes pre-configured with a sample Maven build job that will properly build this application.

      If you first want to see your code, click the Browse tab and click View Commits:


      View Commits

      Click the Build tab, where you'll see the provided Sample_Maven_Build:


      Click the Sample_Maven_Build link to open the job:


      Feel free to review the configuration (click the Configure link). When you're ready, click the Build Now link. The build will get queued, waiting for an executor:

      Waiting for Executor

      Soon thereafter, the build will begin:

      Build Running

      Feel free to click the console icon to track the Console Output. In my case, the build has already completed, so the build indicator ball has turned green:

      Console Output


      Console Output


      Now that we have a successful build, we can configure deployment. Click the Deploy tab and then click New Configuration:


      Complete the Deployment Configuration. As I'll be using this configuration for development, I'll set it to deploy automatically after a successful build:

      New Deployment Configuration

      Click Save to see your new Deployment Configuration:

      New Deployment

      This deployment will run any time there's a new build. To run this build manually, click the gear icon and select Start:

      Start Deploy

      And wait a few seconds for the deployment to succeed:

      Deployment Succeeded


      Click the Java Service link to navigate to your Java Service. There, under Jobs, you'll also find that the Deploy Application job is Complete:


      On the same page, under Applications, click the Test Application icon:

      Test Application

      Then click the Application URL in the window that pops up:

      Application URLs

      Which will open your application in a new tab:



      As this application stands right now, it would require cloud credentials in order to run it. Let's quickly remedy that.

      Updating the Application

      Back in the Git Console, add and empty <login-config/> tag to the web.xml. You can read about the details of Updating web.xml in the Cloud Documentation.


      While were are here, let's also make a visible change to the index.jsp:


      Then commit:

      git commit

      Push the changes to the Developer Cloud Service:

      git push

      Return to the Developer Cloud Service Console and optionally view the changed files:

      Files Changed

      Switch to the Build tab and click the Schedule Build icon (just to the right of the Console icon). In the true spirit of continuous integration, it is also possible to configure Hudson to poll for changes to the repository, but that's now how this sample build has been configured.

      Schedule Build

      When the build completes, remember deployment is automatic. Just return to your browser and refresh the page:


      There is much more to experience with the Developer Cloud Service - Tasks, Code Reviews, Wikis. The plan for this tutorial was to give you enough to started. Are you ready?

      And the MVC specification project is public

      And the MVC specification project is now public at http://mvc-spec.java.net/ so we are on the way!


      Guest post: How to create a newsletter template your marketing team will love

      Today, I'd like to introduce you to a colleague of mine: Tomas. Tomas works with Magnolia's marketing team, where he focuses on developing our corporate website, as well as a number of communications tools like newsletters. He's recently taken a liking to blogging, so I'd like to leave him this stage today, as he has some pretty cool pieces of knowledge he'd like to share.

      Do your CMS editors need to simply (that is, without knowing html, css and other fancy web technologies) create and send out newsletters every week? Do they additionally want to have these newsletters neatly archived on your website, tied nicely to your existing website theme? If you answer these questions with a resounding “Yes!”, there are a few useful tools and functions in Magnolia to get the job done quickly, while keeping everyone happy.

      First, you’ll need your html prototype for your newsletter. The web is full of resources on how to write a proper html email, usually full of tables and inline styles (I'm sure you know how to use Google, but here is one of my favorite resources).

      The use case here is to have your newsletter accessible both on email and via the browser, on your website (“Having trouble reading this email? Click here”...). So to ease you gently into the topic, let’s start with this requirement, as it’s the simplest part: let’s create a new newsletter template on our website.

      We’ll extend our custom home or stkHome (to keep our branding, meta-navigation, footer, etc as inherited areas). Then we’ll wipe out (override) the list of existing components in this new home template and create a new availableComponent in areas > main > areas > content that goes by the name of newsletterTextImage. Of course, we can add or extend others like linkLists or teasers, but for now, let’s work with this one. We’ll also extend stkTextImage and add your custom dialog (for title, text, image, button) and ftl.

      FTL (my templating language of choice - you can also use JSP or others, but I can guarantee it to you that FTL is simpler and easier to use in the long term) should be “email ready” (tables, inline css and other goodies) because we will use it in email rendering and also in the website.

      Of course we can also change our mainArea.ftl and others, depending on our newsletter layout. But for now, we have a new working template (don't forget siteDefinition availability) with one newly available component. So far so good - it’s pretty much just like your regular template.

      And now the magic bit comes in. In this template we can define “variations” and change templates depending on file extensions. Let’s imagine that the default variation for all pages is “html”, which means that if we have a page www.page.com/home.html, then the extension “.html” is connected with this default variation. Now if we create a new variation called “email” and change the url to www.page.com/home.email then we can rewrite some properties, for example templateScript main.ftl, with something more “email ready”. Variations work with the same logic as extends, so if you need to rewrite ftl for contentArea as well, then you have to create a whole tree below (areas > main > areas > content).



      And that’s all. Well, almost. But editors are now able to create a simple newsletter and render it as web content or email.

      If you are using an external campaign tool like Campaign Monitor or Infusionsoft, just open your new newsletter on your public instance of Magnolia, go for the source code and copy it all. Then just put this code into your tool (maybe you will also have to add some elements to code, like the “unsubscribe” button if you’re using e.g. Campaign Monitor). On the opposite end, there’s tools like InfusionSoft that will be injecting “unsubscribe” and some more text to the bottom of your email automatically, so you can just send the html. Or maybe you are using one of Magnolia’s integrations for such tools, such as the Newsletter module, which can also help you with this part of the work. :)

      This post should cover a basic functionality overview and give you something to build on. Frontend developer, page-crafter, template designer or whatever your job title is: let your imagination loose and show us what kind of amazing newsletters you can create!

      And, as a good illustration for this post, here is our latest newsletter. Why not subscribe to it, while you’re at it? http://www.magnolia-cms.com/company/news/newsletter/newsletter-48.email

      JavaOne 2014 Day Three Notes

      Day three was definitely the high point of the conference for me. As anyone who has spoken at tech conferences knows, the point in time when all of one's sessions have been given is the turning point between tempered enjoyment and pure enjoyment of the conference. I was blessed with the scheduling this year; I was all done after Wednesday. This put me in a great frame of mind to enjoy the Oracle Appreciation Event. Day three also saw the culmination of a long running project: the Web Framework Smackdown 2014 edition.

      My friend and colleague Reza Rahman asked me to keep the web framework smackdown meme going for another year. This year I called in quite a few favors to pull together a diverse group of celebrity panelists: Miško Hevery, creator of AngularJS at Google, Pete Hunt creator of ReactJS at Facebook, panelists preparing and Joonas Lehtinen, creator of Vaadin. The panel was moderated by Neal Ford of ThoughtWorks. I rounded out the panel representing JSF. I've learned from previous smackdowns that a confident and comfortable moderator combined with a little prep time just before the panel are the keys to success. We met at 11am for this purpose over Patxi's pizza. From the left you can see Neal Ford, Miško Hevery, myself, Joonas Lehtinen, and Pete Hunt. I don't think Pete and Miško had met before, and it was interesting hearing them trade notes about their approaches to the performance of handling the model update side of their frameworks. From what I gathered, they both see that feature as the most valuable aspect of their frameworks, and they both have spent significant time optimizing that part. When it came time to take it on stage, we started by introducing our different approaches to the task of building a stateful and responsive user interface delivered in a web browser. Angular and React are entirely client side, while JSF and Vaadin are entirely server side. In spite of Neal's earlier recommendation that client side is the way of the future, Joonas and I made the case for where server side makes sense. Briefly, reasons for favoring server side over client side include simplicity, security, integratability (such as mashups), and maintainability. Client side is better when Facebook-sized scale is important, when JavaScript fluency is a non-issue, and when "modern" browsers are a given. You'll have to check out the audio to get the full details. My only complaint with the panel is that it really didn't get smackdown-ish at all. I welcome comments about the client/server UI debate. Perhaps we can get some smackdown action in the comments.

      My last official obligation of the conference was my final booth duty in the Java EE both. This session closed out the JavaOne exhibition, and as such the traffic was a bit light. I was able to take a tour around the exhibition to obtain some schwag for my kids. This year it was novel to see Target with a booth. I've long been a fan (and shareholder) of Target, avoiding Wal*mart at all (unfortunately frequently too high) costs. They were recruiting. JavaOne is not a job fair, but it was still nice to see them representing Minneapolis, home of Facelets creator Jakob Hookom.

      Geert and the NullPointers Freddy, Frank, and Ed Booth duty done, it was on to a bit of fun in Duke's Cafe. As I mentioned in my JavaOne 2014 Day One blog entry, Chicago JUG leader Freddy Guime had put together a band of musician Java enthusiasts called the NullPointers. They allowed me to sit in with them for some songs during their set at 5pm Wednesday. This was a real honor and a great blast. At left, from the left you see Zoran Severac, Mattias Karlsson, of JFokus, Geert Bevin of ZeroTurnaround, and Jim Weaver, Java Developer Advocate for Oracle. At right, from the right, you see Freddy, Frank Greco of the New York Java Users Group and myself. I think my keyboard stand was formerly in the Hackergarten.

      The fun kept on rolling, with the Oracle Appreciation Event. This used to be called the Customer Appreciation Event. I'm not sure why they renamed it. I would probably have given it a pass this year but for my 11 year old who is a big Macklemore fan. I'm glad I went because Macklemore was very entertaining, and Aerosmith put on a great show as well.

      20141001-smackdown-prep.jpg96.55 KB
      20141001-nullpointers-01.jpg74.99 KB
      20141001-nullpointers-02.jpg72.57 KB
      c12bg-openworld-bands-2264324.jpg130.67 KB

      All brand names,logos and trademarks in this site are property of their respective owners.

-  Free Magazines

Free Magazine
-  News
  Wireless Java
Industry News
  CNET News
  CNET E-Business
  CNET Enterprise
-  Weblogs
James Gosling's
-  Tell A Friend
Tell others
Free eBooks |  About |  Disclaimer |  Terms Of Use |  Privacy Policy
Copyright 2001-2006 Gayan Balasooriya.   
All Rights Reserved.