This time I’ve provided the documented Ant build file at the end of this article, which you are welcome to download and use for your own development.

How does it work?

Within the standard Maven project object model, you have the ability to define artifact repositories within the <distributionManagement /> section of the pom.xml file. Maven uses these settings to deploy the artifact that was generated during the build process – which, in our case, simply deploys them to Nexus. This makes it easy to reference the artifact in other projects and ensures that it is appropriately shared (either internally or publicly, depending on how you have configured it). It’s up to you to decide how and when you deploy to Nexus, but the point is that it is in a shared repository. This should be done for you as part of your release process if you use the Maven Release Plugin, although it can be manually uploaded too (either via Nexus or via the Maven Install Plugin / Maven Deploy Plugin). Now that we have our artifact in Nexus, we can simply download it whenever we need it. We don’t want to rebuild the sources to produce another copy of the already released artifact – we simply want to use the same compiled artifact that we originally produced.

We used Ant to create a build script – modelled on the sample script provided in the SAP NetWeaver CE 7.1 Developer Edition installation – that would allow us to run a deployment from anywhere to anywhere. The standard script provided by SAP is tied to the directory where it lives – which is not very useful, since we really don’t need a full NWCE installation just to fulfill a few dependencies. So we decided to combine one of the best features of Maven (dependency management) with the simplicity and clarity of Ant, and have produced a build script with no local ties. The next few sections will explain what you need to make this work and how to setup your environment (the script also includes some documentation).

Setup

You’ll obviously need to have Ant installed for this to work. In addition to this, you’ll need to download the Maven Tasks for Ant and copy them into your {ANT_HOME}/lib folder. The next thing you need is your own internal Nexus repository manager. This is technically not required, as you could simply install all dependencies locally – although it’s more realistic that you’ll want to use a shared repository for your team / company.

Once you have your Nexus repo manager configured, you need to deploy the SAP deployment JAR files to the 3rd Party release repository. These are not made available in any public repo, so you’ll need to host them yourself. I’ve outlined the details I used to upload the deployment libraries in our system, but you’re free to use whatever GAV parameters you like (so long as you update the Ant build file as well). You can find all of these files in the SAP installation directory – just look in the sample Ant script (in /usr/sap/LCL/J00/j2ee/deployment/scripts) for the relative file locations.

Note: I’ve used version 7.1.1 for all of these SAP libraries as I’m running NetWeaver CE 7.1 with Enhancement Pack 1 (more on how to check versions here).

When you run Ant with the build file, it will automatically resolve and download the dependencies via Nexus (using the Maven Tasks for Ant). So all you need to do is specify what you want to deploy / undeploy, and then let Ant & Maven do their thing. If in doubt, simply run Ant specifying the build file and the -projecthelp option.

Good luck, and I hope this has helped you!

Download: SAP Deployment with Ant

I guess the best place to start is to look at the goals I had for our code reviews. I’ve summarised them as follows:

1. Improve quality ^[1]
2. Share ideas
3. Share knowledge of the code
4. Share ownership of the code
5. Mentor junior programmers

You’ll notice that most of these points can be summarised in one word… TEAMWORK!

Teamwork

I have already seen improvement in a number of these points in only a month. We have ensured that we always submit code for review before allowing it to be handed over for testing, and this has caught a variety of issues in the early stages of development. The issues we’ve identified so far range from subtle issues such as usability, terminology and coding standards to bigger issues such as EIS integration and design.

I also found that the code review process has stimulated more internal dialogue within the development team about how we should go about solving some of the user stories on our task list. As a result, we have achieved the goals of sharing knowledge and ownership of the code and sharing ideas. In turn, this has improved the quality of what we deliver to testing and ensured consistency in our approach as individuals within the same team.

When comparing code that has been reviewed against code that has not been reviewed, it is quite clear that the code reviews help us to deliver code in a consistent manner across the team. That’s quite a big strength in my opinion, as it means that we’re all playing by the same rules, abiding by the same standards, and finding consensus in our approach. Maintainability has improved because the code always looks familiar – so less time is spent figuring out what the last guy did before trying to fix a bug or develop a new feature.

Personal Benefits

I’ve found that I can keep a much better eye on our delivery by simply monitoring the code reviews. It gives me an incremental view of the changes to the codebase, and allows me to check that we’re meeting the standards we’ve set for quality, simplicity, maintainability, and so on. I think this is essential for any Tech Lead, and also achieves the goal with minimal interference. The productivity of the team should not suffer unnecessarily in order to meet standards – there is often a less disruptive way of achieving this.

What to try next

When we started the code reviews, we were unsure whether to do pre-commit or post-commit reviews. We decided to start with post-commit reviews, as this would be the least disruptive to a familiar development process and would allow us to focus on one new area at a time. Now that we’ve been doing code reviews for a while and have stabilised the process, I’m quite keen to try pre-commit reviews for a sprint or two. I’m sure there will be obstacles to overcome, but the best way to evaluate the two methods against each other is to try them both.

^[1] There are many different views on what “software quality” means. I personally like the points outlined in Wikipedia: http://en.wikipedia.org/wiki/Software_quality#Software_quality_factors

One challenge we have is fully integrating this into our development environment, as some developers work in ABAP and others in Java. The Java developerment environment neatly integrates with Review Board, but the ABAP has some interesting obstacles. What we’ve done to overcome this challenge is to write a proof of concept application in ABAP that allows a developer to export ABAP code (in a neat human-readable form) into a Subversion repository. From there, the developer can request a code review using the post-review command line tool. It all works as expected, but it’s still quite a manual, time-consuming process. We hope to develop this further, making it much easier to use, and roll it out to the other development teams.

The next decision we have to make is to choose whether to do pre-commit or post-commit reviews. Both have their strengths and weaknesses, so we’ve decided to try them both out before making a firm decision on how to take it forward.

Only a week or two in, and I’m already seeing the benefits of implementing Review Board! More updates to come as we iron out the creases in our review process…

PS: Buy the book! It’s short and to the point, and very well written. I’ve already ordered his follow-up book Even Faster Web Sites to be delivered today!

The book covers 14 rules for improving performance on web sites, concentrating  mostly on front-end optimisations that can dramatically improve the responsiveness and user experience of your site. However, some of the rules involve changes on the server – for example, enabling gzip compression. The full listing of the Yahoo! Performance Rules can be found here.

Below is a brief summary of how to configure some of these rules in SAP NetWeaver. I’m using NetWeaver CE 7.1, so you may need to adjust these slightly if you’re running a different version. All configuration is done within NetWeaver Administrator > Configuration > Infrastructure > Java System Properties > Services, so I’m only going to mention that once to avoid repeating it many times over. I’ve also made an effort to reference the SAP Help docs that I’ve used to compile this summary, which you should find at the end of each section.

Rule: Add an Expires or a Cache-Control Header

The first thing to point out here is that NetWeaver has two cache control settings: one for the server and one for the client. Before understanding how to configure each of these, you need to know what it is that you’re configuring and the implications of the changes you’re about to make. I’ve included a diagram from the relevant SAP Help page (full reference below) to show the architecture of the ICM Server Cache.

The full explanation that accompanies this diagram can be found here: https://cw.sdn.sap.com/cw/docs/DOC-107069

Right… now that you have a better understanding of how caching works on the server, you’re ready to configure it. I assume you’re already familiar with the standard HTTP Cache-Control header, but refer you to the full explanation here if not: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9

In order to change the cache configuration, you need to find the HTTP Provider Service in NetWeaver Administrator and modify the following properties:

SapCacheControl – This should be set to the expiration period (in seconds) of the cached resource.
CacheControl – This can be set to any of the cache-response-directive values specified in the HTTP Specification (see link above for a reference to the section on Cache-Control).

You could argue that the server-side cache isn’t exactly what Steve Souders was talking about in his book – but when reading the documentation on the SAP Help site, you’ll see that the SapCacheControl value is also used as the Cache-Control max-age response directive… so it will have an impact on the cache status of web resources.

SAP Help Reference: https://cw.sdn.sap.com/cw/docs/DOC-100645

Rule: Gzip Components

Enabling gzip compression is fairly straight-forward. Just find the HTTP Provider Service in NetWeaver Administrator and modify the following properties:

AlwaysCompressed – This is a list of all the file extensions or MIME types that should always be compressed.
NeverCompressed – This is a list of all the file extensions or MIME types that should never be compressed.
CompressedOthers – Boolean value to indicate whether all other file extensions or MIME types (i.e. those not listed in either AlwaysCompressed or NeverCompressed) should be compressed.
MinimumGZipLength – Specifies the minimum size required for gzip compression to be applied. This property works in conjunction with AlwaysCompressed and CompressedOthers (i.e. the resource must be listed for compression AND larger than MinimumGZipLength in order to be compressed).

Note: File extensions must be in the format “*.ext”. Any entries without an asterisk will be treated as MIME types.

SAP Help Reference: https://cw.sdn.sap.com/cw/docs/DOC-111485

You can also dynamically enable compression for Servlet / JSP responses by passing special headers in the response. These headers are not sent to the client, but rather instruct the HTTP Provider Service to compress the response before sending it on to the client. These headers override the HTTP Provider Service configuration described above. If specified, the presence of these headers will force the HTTP Provider Service to either compress or not compress the response – regardless of what is configured elsewhere.

The header values themselves are configurable within the Web Container Service, and are described as follows:

HeaderForCompression – Specifies the header name that must force compression when present in the response
HeaderForNoCompression – Specifies the header name that must prevent compression when present in the response

To use this in your Servlet / JSP, simply set the relevant header to “true”.

SAP Help Reference: https://cw.sdn.sap.com/cw/docs/DOC-100076

Rule: Configure ETags

ETags are very elusive within the SAP Help docs. Despite much trawling, I could only come up with a few minor references to indicate that it exists – however no details could be found. I did find a SAP Note that mentioned a fix to ETag functionality in NW 7.0 – see Note 1020365.

If anyone manages to come across more information on this, please post a comment. I’d be interested in finding where it can be configured.

Criticism

While making all these configuration changes, it’s not hard to see that NetWeaver Administrator is lacking the user-friendliness that it should offer to administrators. It a fairly poor means of managing a system as it has been built to be as generic as possible. Unfortunately, in this case it means that there’s a lot it just doesn’t do very well because it’s trying to cater for everything in one go. To illustrate my point, simply try to modify the list of MIME types within the HTTP Service (see Mime property). This list is likely to be very long, regardless of how you configure it. What do you do if you want to add one extra MIME type? Well, in that case you need to copy the list already there and paste it into Notepad, add the item you want, then re-insert the entire list into an input field only wide enough for about 20 characters. To put that into perspective, the default list of MIME types is just under 4000 characters long. Not only is the input field far too small, but surely an administrator should be able to modify the existing list rather than recreating it to make a small change? Even worse than this is the fact the modified property text is not wrapped in the table cell. So if you do decided to add a MIME type, you lose all visibility of what has been configured as you can only see the first few characters before they disappear. I can’t say I’m surprised though. Usability has never been something that SAP do well… or at all, for that matter. However, taking visibility of the configuration of a system away from the administrator is a very dangerous thing to do. This issue very clearly illustrates how poor usability can have very far reaching consequences, and why it is so important to get it right!

This is by no means a comprehensive review of the how’s and why’s of each of these rules, nor does it go into much detail about each system property described. I intentionally kept this fairly straight forward so it can serve as a reference guide, and have instead provided links to more detailed documentation wherever I can. After all, the links are where I got the information in the first place – so it’s only right to give the original author full credit for it. I’m just hoping to save some of you time in finding the right resources.

I hope this has been helpful, even if it was nothing more than a prompt to look into other areas where NetWeaver can be configured to operate according to what you need.

Why join an open source project?
Everyone has the capacity to get involved in something and help out, and software developers are no exception. I’ve always been involved in building software for business use, which has a lot of challenges and rewards – but it doesn’t really improve anyone’s life in any significant way. My reason for joining an open source project is to contribute to something that really matters… something that might genuinely improve the lives of other people. For this reason, I’ve focused on finding a project that has this as one of its core objectives.

Why OpenMRS?
The answer to this question is pretty simple… I have fairly limited “free” time as it is, so I wanted to make sure I join a project that I believe in. OpenMRS is clearly focused on providing software that can improve the lives of millions of people – particularly in the developing world – so this immediately caught my attention. My original career plan was to study medicine and become a surgeon, but after finishing school I made the decision to study software engineering instead. I don’t regret that decision, but I’ve never lost my interest in medicine, and joining the OpenMRS project gives me the opportunity to work in both.

What’s next?
When joining any new project there is always a lot to learn. Others may have been involved for years, but you have to learn the ropes before you can be of any use to the existing team. So my focus for the next few weeks will be to learn about OpenMRS from every conceivable perspective. What problem is the system trying to solve? How does it work for the user? How has it been designed? How is the data model structured? However, the biggest challenge will be gaining enough understanding of the medical domain for the system to make sense. Very fortunately, the technical foundation is quite familiar territory – so the biggest obstacle is domain knowledge.

I’ll follow up in the coming weeks with some details on how to contribute to an open source project – entirely based on my experience, rather than a definitive list of “do’s and don’ts”. Until then, I’ll be buried in documentation!

HasThisTypePatternTriedToSneakInSomeGenericOrParameterizedTypePatternMatchingStuffAnywhereVisitor

Believe it or not, it really does exist. It’s contained within package “org.aspectj.weaver.patterns”, and can be verified here: http://www.springsource.com/repository/app/bundle/version/export?name=com.springsource.org.aspectj.matcher&version=1.6.8.RELEASE&package=org.aspectj.weaver.patterns

Has anyone else found anything longer than that? Now I’m curious to know what else is out there!

I’m also beginning to wonder whether a new site needs to be created called www.codecompleteme.com in the same spirit as www.autocompleteme.com

Another critical part of our environment is our continuous integration system - Hudson. This is configured in a fairly standard way; checking for changes in Subversion, updating the local workspace, building, testing, deploying, etc. This automation takes away the tedious, repetitive tasks that a developer would otherwise have to do themselves. It also means that these tasks can be done in a controlled environment on the build server.

One particular piece of the puzzle is still missing, though. That’s the creation of a Build entity in TargetProcess upon successful deployment to our shared development server. Having this task automated will ensure that for every version of the product that is deployed to our shared environment, there is also a corresponding Build in Target Process – allowing any bugs to be logged against the correct build. This has the knock-on effect of adding a lot more value to the quality reports that are delivered with TargetProcess… effectively allowing me to monitor the bug trend across a number of builds.

To solve this problem, I’ve created a Maven plugin for this exact purpose. This has been hosted on Google Code so anyone can suggest changes or participate in the project. I’m busy working on the first release, and will make this available on the central Maven repository as soon as it’s ready. In the meantime, if you have any interest in this, it would be great to hear your ideas. At the moment, my primary goal is to get the Build creation mojo complete – but I’ll then add other functionality if it seems suitable and there is interest.

You can have a look at the project here if you’re interested: https://code.google.com/p/maven-targetprocess-plugin/

One of my biggest combined strengths/weaknesses is that I’m a perfectionist in my work. This works to my advantage in that I simply refuse to deliver bad quality work – but it also works to my disadvantage in that I sometimes fix things that aren’t broken. Don’t get me wrong here – I’m very much in favour of refactoring. I’m just conscious of identifying when refactoring has degenerated into needless changes without adding any real value.

So how does this tie into Sonar 2.0, you ask? Well, I’ve recently upgraded to the latest version and was looking into the cool new features it brings – in particular, the LCOM4 measures. This is excellent when used appropriately, but can also be the cause of the dangerous “refactoring” mentioned before.

For those of you who aren’t familiar with LCOM4, here’s the simple definition (as quoted from the Sonar Metric Definitions page):

LCOM4 measures the number of “connected components” in a class. A connected component is a set of related methods and fields. There should be only one such component in each class. If there are 2 or more components, the class should be split into so many smaller classes.

This is a great measure of the complexity of your code. Simply put, it helps you identify when your classes fail to meet the Single Responsibility Principle (or are heading in that direction). Well – at least, that’s the basic idea. The problem comes in when you take the definition as gospel and forget that you need to do some interpretation of the metric yourself.

By ignoring the rule altogether, you run the risk of developing a product that grows in complexity and therefore becomes harder to maintain, troubleshoot, extend, etc. But by accepting the rule without question, you run the risk of adding complexity to an already decent design. You need to find the middle ground for your own situation.

To put this into a real world example, consider the design patterns that we all use in our software designs - in particular, the Abstract Factory pattern. When analysed according to LCOM4 rules, the Abstract Factory is likely to be a high scorer. I’ve seen this in one of the Abstract Factories in one of my own projects, but I’m not about to go changing my design or implementation to reduce the LCOM4 score for this particular class just yet. That’s not to say it can’t be improved – I just need to be clear about how reducing the LCOM4 score is going to improve my code. After all, the metrics attempt to expose problems that should be addressed in the design process in order to produce better code – not the code designed to make better metrics. While this process is cyclical to an extent… the desired outcome should be better code, not necessarily better metrics.

Of course, there are good ways of reducing the LCOM4 score of an Abstract Factory through refactoring, but my point is that you must intelligently assess what the problem is and how to solve it before simply diving in and making changes.

Having seen the benefits of static code analysis performed regularly as part of a continuous integration process, I will never go back. Sonar is an amazing product, and I definitely recommend looking into it if you’re not already using it!

The plan actually started in December with Martin Fowler’s UML Distilled, which I found to be an excellent introduction to UML 2. January followed with Professional Apache Tomcat 6 – which I’m admittedly still busy reading, although over half-way through. February then continued with Sun Certified Enterprise Architect for J2EE Technology Study Guide (the book is actually shorter than the title though), which I have just finished reading.

UML Distilled
I’ve always been a big fan of Martin Fowler’s books. He has an excellent writing style that makes the content easily understandable, and he gets to the point clearly and succinctly. UML Distilled is a brilliant introduction to UML 2 and goes into a reasonable level of detail for the most commonly used diagrams. Some of the less frequently used diagrams are also covered, but in only enough detail to give the reader a basic understanding of their purpose.

Fowler seems to approach UML, and pretty much everything else software-related, in a very pragmatic way. He clearly advocates the use of UML, but in a way that works for you in your environment. Every company is different, as is every project – and as such, your usage of the tools should reflect this. Although do bear in mind that if you deviate too far, you eventually get to the point where you’re not using a modified version of UML anymore – you’re using a custom language inspired by UML. This can be a bigger difference than it sounds!

I really enjoyed reading this book – and we now have two copies in the office so there’s no waiting time for anyone else that wants to read them. Highly recommended!!

Sun Certified Enterprise Architect Study Guide
I’ve just finished reading this book today. Well, I’ve read everything except the last chapter – but that’s preparation for the assignment part of the certification, which I’m not doing just yet. The first 7 chapters are intended as preparation for the SCEA Certification Exam (Part 1 of 3) and provide a very good high-level overview of a number of topics, all of which are very relevant to modern software development.

Admittedly, the section on EJB was still based on the old version – referring to home & remote interfaces, rather than annotations – but this could’ve easily been my fault in not properly reading the book overview on Amazon before buying it. That said, the explanation was still good and the rest of the book is very interesting.

I particularly like the fact that each chapter starts with a prerequisites section, which clearly establishes the knowledge you are assumed to have before continuing. This is very useful for professionals that have been involved in software development for many years and have a good understanding of the issues that affect it – which is exactly the target market for the certification itself.

It is a true study guide, in that everything is in summary form and assumes the reader already has more in-depth knowledge of the individual subjects, where required. This is not a course book designed to teach you everything – but you’re probably not ready for this certification if you don’t already have the in-depth knowledge anyway, whether by hands-on experience or otherwise.

Overall, I found this a very interesting read, and definitely worth the few hours it took to get through it – it’s only about 200 pages. Also highly recommended – although I haven’t taken the exam yet, so can’t vouch for how close it matches the exam content. Look out for the new edition being released within the next month!

LinkedIn Amazon Reading List and our Company Library
In the last few months, I’ve started using the Amazon Reading List in LinkedIn. It’s a very useful app that allows you to tell everyone what you’re reading, and recommend books once you’ve read them. I’m already following two other reading lists of current & past colleagues, which gives me some interesting ideas of books that I may want to read in the coming months. I’d highly recommend that you participate in this, or perhaps some other shared list that you have access to within your company.

We’ve also set up a company library, which hopefully encourages people to read more and share what they’ve read with co-workers. The library is relatively small at the moment, but it is growing fast and we now have a somewhat regular order of new books to stock up the shelves.

Next up…
So, now that I’ve finished those books… what’s next?

In parallel, I’m starting on these two excellent books – both of which I’ve read before, but I honestly believe they are worth reading every few years!

Design Patterns: Elements of Reusable Object-Oriented Software
Core J2EE Patterns: Best Practices and Design Strategies

What are you reading? Got any suggestions that I can add to my “to-read” list?

Performing this check on an ABAP system and a Java system is obviously very different. In an ABAP system, you will look for the version information within SAPGUI. However, a Java system provides a web interface for all administrative functions.

Using SAPGUI to check the version of NetWeaver (ABAP Application Server)

1. Log on to the system using SAPGUI
2. On the main menu, choose System > Status…
3. In the “System: Status” dialog that opens you’ll see a section in the middle-right called “SAP System data”. Click the icon next to “Component version” to show details of all the components installed on your system
4. The component you need to look for is called “SAP_BASIS” and is usually at the top of the list.

Release is used to identify the major release of NetWeaver, and Level is used to identify the support pack installed. The list below illustrates how to interpret the values in these fields:

Using a web browser to check the version of NetWeaver (Java Application Server)

Before you start: To access the URL below, you will need administrator privileges on the SAP system in question.

1. Using your web browser, go to the following URL – http://<hostname>:<portnumber>/sap/monitoring/SystemInfo
   Be sure you replace your hostname and port number with the correct values. The port number (if unchanged from the default) will be 5XX00, where XX is the SAP system number.
2. Look for the section called Software Components. This will list the main components used to determine which version you’re running. You’ll most likely see entries for “sap.com/SERVERCORE” and “sap.com/J2EE-FRMW”, and their associated versions. You can click on the All Components link if you want to see more details.

In the Version field, you’re likely to see something like this “7.11 SP1 (1000.7.11.1.0.20081122210100)”. The key info here is quite clearly the first part, where it has identified the version as NetWeaver 7.1 with Enhancement Package 1 and Support Pack 1.

In case it hasn’t already become obvious, the last number in the Release / Version identifies the Enhancement Package – e.g.
701 = 7.0 Enhancement Package 1
711 = 7.1 Enhancement Package 1

I’ve mentioned the term Enhancement Package in the list above, which is still quite foreign to most SAP users – largely due to the fact that the majority of SAP installations are not yet up to NetWeaver 7.0, which is the minimum version required to support this feature. I found the following article which explains what Enhancement Packages are, and would strongly recommend that this be added to your list of “must read” articles: http://saplab.org/2011/01/must-know-about-enhancement-packages/

There is a lot of content available on the Enhancement Framework and the Switch Framework, which are both available since NetWeaver 7.0. These are both important for the technical team to understand before migrating to NetWeaver 7.0. If you’re an ABAP developer… this is perhaps the most key new feature that you need to understand! It’s a very simple concept, but also very important to ABAP development (unless you’re only writing very basic programs) and equally important when implementing Industry Solutions, as these are all built using the Enhancement Framework and activated using the Switch Framework. If time allows, which it seldom does these days, I will try post more information on these two topics in the future.

I hope this has helped you find the information you were looking for. And as usual… if you notice anything above that looks incorrect, please let me know so I can correct it.