The Grail is Eating Properties

July 8, 2012 Leave a comment

Problem: You are developing a Grails application. You are using scaffolding to build out your views and controller actions. Yet for some mysterious reason Grails is not rendering some properties in the views.

Solution: Did you designate some properties as transient? If so, then by default Grails does not generate transient fields in views. To fix this you need to install the template plugin, and change the value of the persistentPropNames variable:

  1. Install the view templates:
    1. grails InstallTemplates
  2. Now open the pertinent templates (list.gsp, show.gsp) in src/templates/scaffolding
  3. Change the line that reads allowedNames = domainClass.persistentProperties*.name to allowedNames = domainClass.properties*.name for each template.
    1. Note you are changing persistentProperties.* to just plain properties.*. This opens the door for Grails to generate fields in your views that include your transient properties.

Thanks to lo_toad for pointing this one out. This solution saved me so much time.

Advertisement

Filed under Software Tagged with , , , ,

Living In A Subversive World

June 25, 2012 Leave a comment

This describes how to use Subversion on a day to day basis. If you have inherited or been assigned to a software development project that uses Subversion, but are unfamiliar with how it works and how to use it, then this post is for you.

So What is Subversion?

Apache Subversion is a Source Configuration Management (SCM) system that has one central repository, usually located on a web server. Each of us works on our own copy of the Subversion-controlled project. When post our changes back to the central repository, Subversion merges them with the existing code and increments the Revision number. Anyone who then updates their local copy of the project will now see the changes we just made. As long as everyone performs frequent updates to their local copy, it all works fine.

What’s So Great About It?

Subversion uses the copy-and-merge philosophy, in contrast with the Lock-Modify-Unlock method used by older SCMs such as RCS, and Microsoft Visual SourceSafe (VSS). In these systems, only one person can change a file at a time, while everyone else is locked out. Veterans of RCS or VSS may point to a risk of running into conflicts and other problems when using Subversion’s copy-and-merge. While the risk of conflicts is still present when two or more people are working on a file, in practice this is only a concern when these people are changing then same part of a file.

For example, suppose you and I are working on OurBigModule.java. You are working on lines 100 to 150, and I’ve made changes to lines 30 to 50. Just before I commit, I update my local copy of the project. Then I commit my changes to Subversion. When you have finished your changes you too update your local copy, but now Subversion merges the changes I made with your local copy. Now you are up to date with the central repository. You run the full suite of unit tests, they all pass, and you commit your changes to the central repository. The end result is the most recent version in the central repository has both mine and your changes in it.

Subversion really shines when it comes to committing changes. Unlike another of its predecessors – CVS (Concurrent Versioning System) – Subversion uses atomic commits. Say you have a dozen changed files to commit, and one of the file commits fails because of a conflict. Subversion will roll back the entire change set – all 12 files. You still have some work to do to resolve the conflict, but at least your repository is in a consistent state.

OK, How Do I Use Subversion?

  1. Install a Subversion client on your local workstation. There are some fine plugins for Windows Explorer and Eclipse such as TortoiseSVN and Subclipse. For this post I’ll suggest using a command line client to help you understand what goes on under the covers with the graphical tools. CollabNet is the command line client I used.
  2. Ensure the executables directory for your chosen SVN client is on your PATH environment variable.
  3. Open a command line window, cd to wherever your workspace is and go: 
    1. svn co http://svn.domain.com/bigproject/trunk bigproject
    2. This will create the directory bigproject in the current working directory, and check out the entire project into there.
    3. The URL is the Subversion repository. Your lead developer can supply this to you.
    4. “bigproject” is the fictitious name of our project in this example.
  4. Write your unit tests. Make some code changes
  5. Update your local copy with any changes others may have made: from the bigproject directory, go 
    1. svn update
  6. Make more code changes. Test and debug.
  7. Now that all your changes are complete, prepare to commit them. First, do an svn update. If you see there were some changes merged in to your copy, run the full suite of unit tests to make sure they all pass.
  8. Commit your changes: 
    1. svn commit -m “A brief note to explain what you changed and why.”

Here are some other useful commands:

  1. Are there any changes I haven’t committed? 
    1. svn status
  2. How do I delete a file and have Subversion know about it? 
    1. svn delete src\java\com\domain\bigproject\OurObsoleteModule.java
    2. Subversion will record the delete when you do an svn commit.

Remember!

Everyone works on their own local copy of the source code. Don’t use a shared version that sits somewhere on a network drive and two or more people are working on it. Subversion is not designed to work that way. It would make it very difficult to figure out who changed what, your unfinished changes will get dragged along with my finished changes when I do a commit, it would just be a mess.

svn update often, at least once a day. I update first thing in the morning, and again right after lunch.

Only place textual source code files under version control. Libraries, JAR files, Word documents belong in different repositories such as Maven, Microsoft Sharepoint, Atlassian’s Confluence, MediaWiki, etc. Unlike text files, Subversion cannot show you why changed what with binary files.

Only commit working code to the trunk. The idea is we should be able to give a demo to our customers at any time by using what is in the trunk. Following this rule will improve your team’s code quality dramatically.

Want To Learn More?

We have just scratched the surface of Subversion. Your best resource is the Subversion Book. Read up on branching and tagging.

Filed under Software Tagged with ,

Personal CI

April 27, 2012 2 Comments

If you could do something that would dramatically improve your job prospects in the event you leave your current employer, would you be interested? What if you could boost the value you deliver to your existing employer, and perhaps get assigned to that cool new project you heard about, would you be interested? Read on…

A popular acronym in the software development world is CI – Continuous Integration – in reference to the practice of performing automated build and test every time a change is made to the software. But CI also stands for Continuous Improvement, an attitude that one never stops learning. It’s a constant pursuit of better ways to do things, of new skills to learn. The Software Craftsmanship movement has as its foundation the notion of continuous improvement.

As we all know, information technology evolves at breakneck speed, effectively reinventing itself every three to five years. If we are to maintain pace with this revolutionary change, we need to keep learning, trying new technologies, and new languages. We need to have that sense of curiosity, of wonderment, of thinking “what if we did this…” and “what’s this “X” all about?”.

And if you don’t? Well, some may be able to stay with their current employer and effectively cruise to retirement. I’ve seen this work for some people. But then what happens if you are laid off, or otherwise need to leave your present employer? Your skills have probably stagnated, and become out of date. Your only hope is to get hired by a company having a similar technology stack and development methodology. But if your skills are in low demand out there in the marketplace, you’re in a world of hurt.

Take charge of your career development. Make yourself the one who gets you the skills and training you need. This is going to mean paying some costs out of your own pocket; however, you may be able to get some tax breaks here – speak with your tax accountant. Attend conferences, either local or out of town. Join your local Java Users Group or Meetup Group. All of this is an investment in yourself that pays off in many ways, not just monetary.

Mentor others in your newly-learned skills. Talk to your boss and offer to run a lunch-and-learn session. Look for opportunities to pair with a colleague to help solve a stubborn problem. The personal satisfaction you get from sharing your knowledge with others is pretty cool.

Filed under Software Tagged with ,

Design is Important, But…

September 22, 2011 Leave a comment

Spending time on software design is important because it helps you solve the big problems up front. Without this effort, developers can get bogged down, or worse, build something that doesn’t meet an important customer requirement. What you want to avoid is spending too much time in the design phase. After all, our objective is to deliver working software to our customer early and often. At some point we need to “get on with it”. The trick is to recognize that point

When do you know when to take a break from design and start building something? Well, one clue is when you find yourselves bouncing back and forth from one design option to another. Ask yourself, might this vacillating be due to a lack of information? If you’re speculating on what may be important to the customer, talk to them. Clarify what their needs are. Ask them what would exceed their expectations, and what would disappoint them.

If you have design options that would equally satisfy your customer, are you lacking some technical information? Specifically, how well do the capabilities of the technology stack support each of your design options? If this is the case, then it’s time to see what will work. Decide what metrics are important enough to help you decide on a design, then go and make a prototype. Take one of your design options, and build it out enough for you to benchmark it. Show it to your customer and get their feedback. Then take your other option, benchmark it, and get customer feedback. Repeat this for a
third option if you have it. Now you have some empirical data to help you with your decision.

Filed under Design, Software Tagged with ,

%d bloggers like this: