I use NetBeans 6 all the time on my laptop and have learned how to configure it
to run more effectively for me.
NetBeans, like any Java application needs room to work, and the default memory settings
for Java and NetBeans are usually not what I consider ideal.
Of course how would they know what is ideal, you need to tell it.
Granted my solution may not be ideal for others, but it’s worth playing with.
I’m using jdk6 update 17.
And even this should work for NetBeans 6, this should work on any platform.

on MAC/Linux/Windows netbeans/6.0/etc/netbeans.conf
netbeans_default_options="-J-Xms256m -J-Xmx512m -J-XX:PermSize=32m -J-XX:MaxPermSize=160m
-J-Xverify:none -J-Dapple.laf.useScreenMenuBar=true -J-XX:+UseConcMarkSweepGC
-J-XX:+CMSClassUnloadingEnabled -J-XX:+CMSPermGenSweepingEnabled"

Any change to this file will require a reboot.

Also, turn on the View->Toolbars->Memory to keep track of the NetBeans memory usage, clicking
on it will force a GC, and you can get a feeling for how much memory your NetBeans
session needs, making adjustments to the maximums above.
And my recommendation is that the maximum (-J-Xmx) setting should never be more than
the RAM on the machine minus 512m, or system memory thrashing may occur.

Additional information can be found at
the NetBeans FAQ on GC pauses
and
the NetBeans FAQ on configuration.

The above settings make a world of difference in the way NetBeans performs for me.

In Java you just have classes (both abstract and concrete) and interfaces. The Ruby language provides classes, modules, and a mix of both. In this post I want to dive into mixins in Ruby.

In the Ruby language a mixin is a class that is mixed with a module. In other words the implementation of the class and module are joined, intertwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class. Before we get started with the mixin examples let me first explain what a module is.

I think of a module as a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but a module can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and seperate classes either at the class or instance level.

Let me define a module, albeit a trivial one, that would convert a numeric integer value to English.

# Convert a integer value to English.
module Stringify
  # Requires an instance variable @value
  def stringify
    if @value == 1
      "One"
    elsif @value == 2
      "Two"
    elsif @value == 3
      "Three"
    end
  end
end

Note that the Stringify module makes use of a @value instance variable. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods defined not in the module itself but in the class that it will be mixed with.

Now let me construct a self contained module that is not dependent on the implementation of any class that it can be mixed with.

# A Math module akin to Java Math class.
module Math
  # Could be called as a class, static, method
  def add(val_one, val_two)
    BigInteger.new(val_one + val_two)
  end
end

The methods in the Math module are intended to be invoked like class methods, also known as static methods. The add method in the Math module accepts two integer values and returns an instance of BigInteger. Let me now define the mixin BigInteger class.

# Base Number class
class Number
  def intValue
    @value
  end
end

# BigInteger extends Number
class BigInteger < Number

  # Add instance methods from Stringify
  include Stringify

  # Add class methods from Math
  extend Math

  # Add a constructor with one parameter
  def initialize(value)
    @value = value
  end
end

I loosely modeled the BigInteger and Number classes after the Java versions. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue   # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue   # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify   # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time! This is a powerful feature. Let me create a module that will be used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
  def format
    "$#{@value}"
  end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format   # --> '$2'

Calling the extend method on an an instance will only extend that one object, objects of the same class will not be extended with the new functionality.

puts bigint1.format   # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a contructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
  def self.extended(base)
    # Initialize module.
  end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.

When a class includes a module the module’s self.included method will be invoked.

module Stringify
  def self.included(base)
    # Initialize module.
  end
end

The base parameter will be a class object for the class that includes the module.

It is important to note that inside the included and extended initializer methods you can include and extend other modules, here is an example of that:

module Stringify
  def self.included(base)
    base.extend SomeOtherModule
  end
end

Vertical centering has always been awkward with css as vertical-align only refers to inline elements within a single line and not to block level elements. However vertical align does apply to table-cells also so we can use this to our advantage in browsers that support display:table such as mozilla and opera.

We can also cater for all IE (IE5 – IE7) via conditional comments and supply them with their own vertical centering routine.

Firstly I’ll describe what’s needed for mozilla. Here’s the main css code:

Code:

The html would look like this:

Html:

Most of the above should be familiar to you but the bit we are interested in is the display:table in #outer. This tells the browser to display this element with the same characteristics of a table which allows us to then use vertical-align:middle. We then nest an inner #container that is set to display:table-cell and this table-cell will then be vertically aligned to the parent as would a table cell.

The inner #inner element is then horizontally centered using margin:auto and that completes the solution for mozilla and Opera. It’s a shame that we need the extra wrappers but this is the safest way to do this. Unlike other vertical centering methods (where you position the element 50% from the top and then drag it back up with a negative top margin equal to half the elements height) the method I describe will always stay in the viewport and will not slide off the top or the side of the screen which is a bad failing of other methods used.

To bring IE into the game we need to do something else because it doesn’t understand display:table. Luckily we can draw on a behaviour that is consistent from ie5 – ie7 and simply involves positioning the outer element 50% from the top using relative positioning and the dragging the inner element back up with a negative 50% relative top position. In other browsers this would bring the element back to the same position but IE drags the inner element back only half its height therefore perfectly centering the element.

Code:

We also need to add overflow:hidden to the outer for IE7 otherwise we get a vertical scrollbar where its not needed.

Nothing else needs to be changed as IE7 and under doesn’t understand display:table and just ignores it. The html stays the same and the only extra css is the 2 lines above. It couldn’t really be much simpler.

One of the best things about Wordpress is the thousands of plugins available for free. No matter how you want to customise your site, there’s probably a plugin to do it. From turning it into an ecommerce store to automatically pulling in content, the possibilities are endless.

When it comes to portfolio sites, you don’t really need a lot of bells and whistles. Your portfolio is all about your work and presenting it in the best possible way, so which Wordpress plugins are the best to achieve this? Which will help your Wordpress portfolio really perform?

Tweet This

Chances are you have a Twitter account, so what better way to show off your work than to put it in front of your followers? The Tweet This plugin installs a cool button on all of your posts and pages, allowing people to Tweet a link to your work. It can also be set up to Tweet new posts so you don’t have to sign up to a service like Twitterfeed.

Our favourite thing about this plugin is that it lets you shortern URLs using a service of your choice. If you’ve got your own URL shortener this is very nifty indeed.

Sociable

Fantastic for generating traffic spikes, Sociable lets you add social bookmarking links on your posts, pages and RSS feeds. Good art, design or photography is social networking gold, so this is definitely a plugin you want to install.

Xavins Review Ratings

It might be a bit old-school, but star ratings are great for visitor interaction. Our favourite plugin for this is Xavin’s Review Ratings. It’s entirely customisable from the number of stars to the size of the fractions to the design of the stars themselves. Intended mainly for review websites, we think it’s cool to let people review your work, so give this a try on your portfolio.

NextGen Gallery

Probably the most comprehensive image gallery plugin for Wordpress, NextGen Gallery provides a huge set of options for displaying your images. From adding custom templates and multiple CSS stylesheets, to using watermarks and slideshows, it’s the only plugin you need for an instant, professional-looking gallery.

FlippingBook

Some people love them and some people hate them, but page-flip sites stand out from the crowd. If you want your portfolio in picture-book format, FlippingBook is the plugin for you. It lets you easily create an interactive Flash album complete with pages that, well, flip!

Smush.it

This neat little plugin is a FrogsThemes favourite, optimising your images in a ‘lossless’ way. As any web designer knows, saving bytes is a good thing. Your portfolio loads faster and there’s less stress on your bandwidth. Smush.it makes it easy for everyone to optimise their image file sizes – once installed, it optimises new images automagically!

Wordpress Super Cache

This plugin also cuts down on your page load time by generating a static HTML file to serve to most of your users. It’s a lot quicker than serving normal Wordpress php scripts and a really useful talent for image-heavy sites like your portfolio. If your work is popular on social media sites, Wordpress Super Cache can help your site handle the resulting heavy traffic. Neat huh?

Audio Player 2.0

Want to add audio to your portfolio? Look no further than Audio Player 2.0. From autostart to autoloop, it has everything you need to make your portfolio literally speak to your visitors. The top advantage for portfolio sites? You can customise the colour scheme to blend in with your design.

Wordpress Backup

Now you’ve installed all these plugins and your portfolio is ace, it’s time to make it safe and secure. Currently, the best plugin that backs up your Wordpress portfolio is simply called Wordpress Backup. It performs regular backups of your upload directory (i.e. images), your theme and your plugin directory. This takes care of a lot of your content, but unfortunately leaves out your database.

For that we recommend a newcomer – Online Backup for Wordpress. This plugin comes with 50MiB of free space in a real life datacentre – your blog posts have never been so secure! We’ve been assured that in the coming months this plugin will backup images, plugins and other file-level items, so watch this space for an update.

SOAP4R is a Ruby library for accessing Web Services via SOAP. Recently I had a chance to explore SOAP4R. Here’s how to get started with it.

Installation

Although Ruby 1.8.x comes with SOAP4R in its standard library, it is an old, buggy version. I highly recommend using the latest gem (1.5.8 as of the this update). It has one dependency, httpclient.

gem install soap4r --include-dependencies

Service

There are many services available to send SMS but I prefer to use,

MailServe-SMS

MailServe-SMS, text messaging service, is everything you need for fast, no-frills, no-fuss text messaging. A quick and easy way to send SMS.

Let’s explore these further.

Method 1: Read the WSDL at run-time

require "soap/wsdlDriver"
wsdl = "http://sms.qlc.co.in/smsapi.wsdl"
driver = SOAP::WSDLDriverFactory.new(wsdl).create_rpc_drive

A single call to a driver factory reads the WSDL file, and creates a driver class for you to use, complete with the methods defined by the service. What if your service requires authentication? The driver inherits methods from httpclient, so you can specify its options as you would for httpclient:

Once driver is get initialised you need to call SMS sending API i.e. SendSMSRequest.

driver.SendSMSRequest("username", "password", "sender_no", "from_no", "message")

Once This will return you response 200 SMS sent successfully on success else if the information submitted was wrong then 500 Information submitted was incomplete.

Method 2: Generate classes from WSDL

SOAP4R installs a command-line utility called ‘wsdl2ruby’ which can generate a client or server.

Coming soon…..