Search This Blog

Saturday, October 27, 2012

Painting Dark Elves On Cold Ones

Painting Dark Elves On Cold Ones (Part 1)

Introduction and Base Coat

                I started off by deciding to paint only a single Cold One for starters. This meant choosing one of them and then choosing the pieces to paint from the plastic panels. I decided on painting the Banner Bearer. Each of the Dark Elves and Cold Ones are distinct. I didn’t realise this at first until I started to look closely at the box and at the actual plastic pieces. They are all slightly different and there is also some choice to be made about the weaponry and the pieces to use. The box comes with extra pieces so some won’t be used. This allows you to decide if you want to arm all with a lance and sword or shield etc. This is pretty cool in giving you these choices and in the model pieces having such a level of detail ... however I always find it difficult to make a choice cos once you make a choice that’s it you can’t change. Ideally I’d be happy if I could paint up both sets of choices and be able to change them as needed. I.e.: If I wanted sword and shields I could remove the lances and replace with a sword. Since that’s not possible the best I can do is to have the spare components saved for later use in future models maybe. 

                Once I’ve chosen which pieces I’m going to paint I mark the pieces with SB, Standard Bearer, on the plastic border. Then I painted the entire components in a slightly watered down black. I only add a little water to make the black a bit thinner so that it covers the pieces in a black undercoat but doesn’t cover up any of the features or fill up any of the fine details. I then leave the thin undercoat of black to dry. Incidentally I chose black as the undercoat instead of white as the Cold Ones and Dark Elf riders are dark coloured models. The colours involved are not bright and colourful, rather they are dark and sombre. So where a white undercoat gives a more cheery, bright set of colours black gives the opposite. Further, as will be seen below, I can actually use the black as part of the paint job instead of just an undercoat that gets painted over. In some places I want to have very thin black outlines around coloured details and this means having a black undercoat. 

                Before I start the main painting I decided to test out some of the colours I’m going to use. Green is going to be a major colour making up a large part of the Cold Ones body so I took the three green colours I’m using for some tests. The three greens are Waaagh Flesh, Loren Forest, Straken Green and they have a kind of dirty green undertone without any brightness or colourfulness which is exactly what I need for the sombre colours of the Cold Ones body. On one of the central plastic pieces holding the components together I did some green shading to see the colour range. This can be seen in some of the photos below. Basically I shaded from the darkest green to the lightest. Then I also used black with the darkest green to go from dark green all the way to black. On the other end I used the light green with white and the light green with yellow to get some lighter shades with white and yellow tones. This shows me the possible colour tones that I will have available to me while painting this model. It’s good to have this as a set of colour swatches so I know what I have available.

Colours Used

- The picture below has the following colours in it:
- Abaddon Black
- White Scar
- Waaagh Flesh
- Straken Green
- Loren Forest
- Ironbreaker
- Bestial Brown (Old Colour Scheme)
- Rakarth Flesh
- Yriel Yellow

Painting the Body

To start the painting of the models I did some dry brushing with the Ironbreaker silver over the chainmail mesh on the legs. I also dry brushed the armour on the legs quickly. This isn’t going to be how it ends up its just a quick dry brush to give me an indication of what it’ll end up looking similar to. Next, I used 'Waaagh Flesh', the darkest of my three green that I’ll use for this model as the first base green colour. I painted this straight over the black undercoat. The areas I painted in this Waaagh Green were the parts of the Cold One that are the spotted skin areas on the model that you can see above. However I didn’t go straight over the black. I did the equivalent of dry brushing the first base green colour over the black so that Id still keep the black in the various cracks and gaps. As you can see from the image above Ive got black in between the various spots. So although a large part of the body was covered in the Waaagh Flesh green as a base it didn’t cover all the black. So first I got the standard brush and dry brushed the body areas. I was careful going over the spotted areas so the black would remain. With the rest I gradually built up the green with layers of dry brush. The underside of the tail is particularly green and although it has some ribbed lines it was the area where the green cover was thickest similar to the area under the belly.

                After the Waagh Flesh dry brushing I followed up with the next lighter green using the Loren Forest. Again I dry brushed the underside of the tail and belly building up the gradually lighter green colour that you can see in the image. The lower parts of the legs where the legs are ribbed I also combination dry-brushed with the Loren Forest and picked out the high lights with the Fine Brush. I finished off the legs, belly and underside of the tail with the lightest Straken Green colour.

                Going back to the body I used the Loren Forest to colour in the various spots randomly on the body and then picked out a smaller number of them with the lightest green the Straken Green. This gave me the spots over the body and made them more interesting than if they were all the same colour. It also gave the model a bit of depth.

Completion of Body/Head and Legs

                The next picture above shows the next lot of things that I painted. The next set of changes in the picture above basically finish of the body and adjoining head model parts and also do the majority of the work on the legs of the dark elf as well.  I do the head and body together as they are going to be joined eventually together and so the colours need to be the same so that the join is smooth and looks natural. Whatever I do on the body I need to do on the head as well and so any colours I mix up, shades or highlights I use on both parts to maintain consistency. As you can see from the image below the head and body have consistency in the colours and the way they have been painted. That way they will look good later on once I’ve cut the pieces away from the plastic and stuck them together. 

At this stage I painted the belts and leather parts of the saddle with the old fashioned paint Bestial Brown before then moving on to the spikes. The belts have some metal buckles and I picked out these pieces by using a bit of Ironbreaker silver.  For the spikes I picked the bone coloured, off-white Rakarth Flesh and I painted each of the spikes with this colour as well as each of the mini spike on the cold ones body. The bone coloured spikes really make the green body look better than when its just various shades of green. After painting all of the spikes I also painted the claws on the feet in the same colour.  Once the spikes where painted in the initial colour I then added some shading to them look more interesting. First I took a brown wash (which was the old Flesh Wash paint) and painted the claws and spikes. Once this was dry I painted a second and third layer with the wash at the base of the spikes and the base of the claws making the wash darker at the base and gradually lighter to the point of the spikes and claws. To finish of the spikes and claws once the washes were dry i took the Rakarth flesh again and painted the tips of the claws and spikes. Then I highlighted by creating 2 gradually lighter layers of the Rakarth Flesh mixed with Scar White and painted on the tips of the claws and spike in gradually smaller amounts and finally on the very tips for the final highlight I used just the Scar White to get a very bright white.  The small spikes along the body are too short for multiple highlights layers so all I did was a layer of the wash, the Rakarth flesh over that and then a highlight on the very tips. This can be seen on the pictures above.

So, what’s next? With the body almost done (and having done the head at the same time in the same manner using the same colours and washes and paints etc) I’m ready to move on to other parts. Having already done the silver shading on the chainmail on the legs I moved on to the rest of them. I painted a thin silver border around the chainmail and then painted the material in Xereus Purple. At this stage it’s just plain purple with no shading or highlights yet.  I also added to the Silver of the armour on the legs and the gold using the Ironbreaker and (old) Burnished Gold. The gold took several layers to get a nice even layer of colour applied over the top of the Ironbreaker layer. Then I applied thin lines above and below the knee gold of Ironbreaker and added Ironbreaker layers of colour over the layers of the dry brushed Ironbreaker.

Wednesday, October 10, 2012

How To Print A List of Comma-Seperated Values Nicely and Remove the Last (',') Comma Value

I recently wanted to take a list of Strings (i.e. List<String> list) and print that out with each value seperated by a comma and inside a set of brackets. The idea is I'd have something like this at the end:


However my first cut attempt at a loop was creating the list above but with a superfluous ',' at the end like so:


Which was based on this code (where list was my List<String>):>

    StringBuilder sb = new StringBuilder("(");
    for (String string : list) {
    sb.append(")");     //close the end bracket

So I decided to find a way or three to do this more nicely. What follows is 3 different ways of implementing this to get the correct implementation using a TestNG test case for testing. Each implementation, which achievs the same thing in each case is in one of the getVersion#() methods. Feel free to use any one of these 3 possible, simple implementations of the same thing to get the nicely comma seperated list with the end comma nicely removed.

  public void testClass() {
    //Create a list of strings to be used in each test case
    List<String> list = new ArrayList<String>(Arrays.asList("String1", "String2", "String3"));
    //setup the expected result string based on the list above
    final String EXPECTED_RESULT = "(String1,String2,String3)";
    StringBuffer sb = getVersion1(list);
    System.out.println("1st string test:" + sb.toString());
    Assert.assertEquals(sb.toString(), EXPECTED_RESULT);
    sb = getVersion2(list);

    System.out.println("2nd string test:" + sb2.toString());
    Assert.assertEquals(sb2.toString(), EXPECTED_RESULT);
    sb = getVersion3(list);

    System.out.println("3rd string test:" + sb3.toString());
    Assert.assertEquals(sb3.toString(), EXPECTED_RESULT);

   * This method puts the comma first so that we have the extra comma at the
   * start and then uses the deleteCharAt() method to delete the 1st ','
  private StringBuffer getVersion1(List list) {
    //begin 1st case: ',' at start and deleteCharAt(0 or 1)
StringBuffer sb = new StringBuffer("(");
    for (String string : list) {
    sb.deleteCharAt(1); //remove 1st ',' symbol (or if extra char's before bracket increse number)
    sb.append(")");     //close the end bracket

    return sb;

   * This method puts the comma at the end in the common wayand then uses 
   * the deleteCharAt() method along with the length of the StringBuffer
   * to delete the last ',' symbol from the list before appending the ).
  private StringBuffer getVersion2(List list) {
    //begin 2nd case: ',' at end and deleteCharAt(last character)
StringBuffer sb2 = new StringBuffer("(");
    for (String string : list) {
    sb2.deleteCharAt(sb2.length() - 1); //remove the 1st ',' symbol
    sb2.append(")");     //close the end bracket

    return sb;

   * The final method of implementing this places the excess ',' at the end like 
   * is standard but then does the delete and append(")") steps in a single step
   * via the replace() call which replaces the lat ',' with the ')' bracket.
  private StringBuffer getVersion3(List list) {
    //begin 3rd case:  ',' at end and replace the last character with the bracket achieving both at the same time
    StringBuffer sb3 = new
    for (String string : list) {
    sb3.replace(sb3.length() - 1, sb3.length(), ")");

So there ya go, 3 different methods all very similar, to implement a comma-seperated list without the pesky comma at the end of the list and implemented in a TestNG test with Assertions to prove it worked as expected.  Note: In all 3 cases the performance is pretty much the same. When looking at the deleteCharAt() followed by an append() as compared to a replace() call they are pretty much identical in terms of what they are going to need to do. Although the internals vary the key performance hit is the call to the System.arrayCopy() which is where the time is spent. Either way there are 3 calls to System.arrayCopy() to perform this work, which reeally should be unsuprsing since in both cases we are doing pretty much the same thing just reducing the number of lines required to implement it. My choice is the 1st option as it looks the neatest (even if it does take one line more than the replace() method).

How To Use: javap With Eclipse IDE

I could write a blog post about this .... but instead ill let the following link do all the talking for me:

So there ya go!

Wednesday, May 9, 2012

JDK8 Roadmap/Timeline to Release

JDK 8 Release Timeline Information

I’ve been following both the JDK7 and then JDK8 development blogs for java for some time now as they both have large numbers of changes to the language (much like the large number of changes in JDK5 (generics, enums etc) and unlike JDK6 which was not much of a change at all). Thought that you may be interested in the following links which now give a timeline for the release of the next Java version JDK8:

To quote from the above source, here is the proposed milestone development schedule:
2012/04/24 - M1
2012/06/14 - M2
2012/07/30 - M3
2012/09/11 - M4
2012/11/26 - M5
2013/01/30 - M6 – Feature Complete
2013/09/?? - GA – General Availability
The expectation at the end of M6 is that all features and new test development will be complete with the exception of work on component JSRs, which will be given additional time to bake until early May 2013. Between M6 and GA the tolerance for further changes will decrease in steps, with general bug fixes admitted up until early April 2013, only P1-P3 bug fixes until mid-June 2013, and only showstopper fixes after that.

This version should have the following main changes (of which the inclusion of closures/lambda calculus functionality will IMHO be one of the biggest changes ever introduced in Java ... larger even then the introduction of generics in JDK 5):

  • Project Coin – language changes...half of which were introduced in JDK7 and which you can read about on the web
  • Project Jigsaw – breaking up the monolithic sized JDK into separate MODULES with dependencies (a bit like Gradle/Maven/Ivy but for Java) ... more detail/links at: and quickstart guide with examples on Mark Reinholds blog: 
  • Project Lambda – long standing effort (discussed since JDK5 and maybe even earlier) to introduce closures and related functionality into java: , see here for one of the latest documents providing information:   IMHO this will be a huge change to Java and the way programming occurs (as this pushes java towards a LISP style functional programming type language) and this is without doubt the change I (and many other developers also) are looking forward to the most.

Its still a way away yet to the release date ... but worth keeping in mind when considering updates to the SOE used by your work place (or home projects) and when to make the jump from JDK6 to JDK7/8??

Notes: On JSR 337:


By the way the following link also has the dates for the JDK 8 JSR 337 Spec and its various Milestones:

This is the primary web page for JSR 337, the Platform Umbrella JSR for Java SE 8.

Expert Group

  • Andrew Haley (Red Hat)
  • Steve Poole (IBM)
  • Mark Reinhold (Oracle)
  • TBD (Google)


2012/7Expert Group formation
2012/9Early Draft Review
2013/1Public Review
2013/6Proposed Final Draft
2013/8Final Release

Mailing lists

There are two mailing lists:
  • java-se-8-spec-experts is the Expert Group (EG) list. Only EG members may subscribe and post to this list, but the archives are public.
  • java-se-8-spec-observers is for those who wish to monitor and, perhaps, discuss the EG's progress. Messages sent to the primary EG list are automatically forwarded to this list. Anyone may subscribe to this list, and any subscriber may post. EG members are under no obligation to follow the traffic on this list.
A formal feedback channel, most likely in the form of an issue tracker, will be set up when a draft specification is available for review.

Differences in Creating a Servlet in versions 2.5 and 3.0 Of the Servlet Spec.

Differences in Servlet Definitions between v2.5 and v3.0

The following 2 examples show the difference between how a Servlet Java Class and associated web.xml deployment descriptor was changed in the upgrade from version 2.5 to version 3.0 of the Servlet Specification. I found this a simple and interesting look at the way the definition of a Servlet in code has now been simplified through the use of annotations from JSR 175.

2.5 Version of Servlet Definition 

Java Class Of Servlet in 2.5

public class MyServlet extends HttpServlet {
    public void doGet (HttpServletRequest req, HttpServletResponse res) {

Deployment descriptor in 2.5 (web.xml)


3.0 Version of Servlet Definition 

Here is the much simplified version written to the Servlet 3.0 API. As MyServlet is annotated as a servlet using the @Servlet annotation, it gets initialized during the start-up of the web container. Note that the deployment descriptor is optional in this case.

Java Class Of Servlet in 3.0

public class MyServlet {
    public void handleGet(HttpServletRequest req, HttpServletResponse res) {

Deployment descriptor in 3.0 (web.xml) - Optional