BitLet.org

Good News! (or perhaps Old News) For torrent leechers this could be an alternative. But for those who do not like to have BitTorrent client fill up your hard disk space but still love to use torrent when needed, then BitLet is definitely the answer for you. BitLet is a cute web-based Java applet that allows you to download torrent files on a computer that doesn’t have a BitTorrent client installed.

Downloading a torrent from this applet is simple. All that is needed is to copy the torrent URL you wish to download and paste it into a box as shown below. Or select your local .torrent and then click download torrent.

BitLet - Type torrent url

Click the download button to start torrent-ing and you will be prompted to allow downloading the applet if this is your first time using this. Simply download this and unblock the installed applet if you have active Windows Firewall. And a small dialog will pop up showing the status of the torrent.

BitLet - Download Status

As depicted above, most of relevant information is shown on the box: transfer rate, downloaded size, file name (shh… censored ), number of current seeders, number of current leechers, and also edit your settings. But that’s not all, you can also upload your file to BitLet and share it to your friends to leech or even consume video streaming. Check out the blog here for development updates. Happy leeching!

So far I’ve been working with some IDEs out there like Microsoft Visual Studio (including Express edition), Eclipse for PHP, Zend Studio, and PHP Designer, and to me Visual Studio is the most developer-friendly IDE. But this task is still repetitive to me and personally I am into the notion of DRY (Don’t Repeat Yourself).

Well, I finally found a way to resolve this in PHP and I’m going to share this. The code is extended based on a sample file from Zend QuickStart.

/**
 * This class is a helper class that allows developer to
 * create an object model easily by simply inheriting and
 * declaring their desired variables as public in the child class
 * and seamlessly creates a pair of getter and setter functions.
 */
class JLoe_Model_Object
{
  /**
   * The regular expression for get method name.
   *
   * @var string
   */
  const REGEX_GET = '/get.*/';

  /**
   * The regular expression for set method name.
   *
   * @var string
   */
  const REGEX_SET = '/set.*/';

  /**
   * Get the value of a property with method syntax.
   *
   * Map method calls to get and set the declared public variables.
   * This is used to help to create magic get and set functions seamlessly.
   *
   * @param  string $method method name
   * @param  mixed  $param  parameter values to be passed
   * @return property value or this object
   */
  public function __call( $method, $param )
  {
    // Check whether it's a get or set method, else throw exception
    if ( preg_match( self::REGEX_GET, $method ) ) {
      $isGet = true;
      $propName = str_replace( 'get', '', $method );
    }
    elseif ( preg_match( self::REGEX_SET, $method ) ) {
      $isGet = false;
      $propName = str_replace( 'set', '', $method );
    }
    else { throw new JLoe_Model_Exception( 'Invalid method' ); }

    // Check whether property name exists
    $propName = ucfirst( $propName );
    if ( ! property_exists( $this, $propName ) ) {
      throw new JLoe_Model_Exception( 'Invalid method' );
    }

    // Perform respective method call
    if ( $isGet ) { return $this->$propName; }
    else
    {
      $this->$propName = $param[0];
      return $this;
    }
  }

  /**
   * Map variable access onto the underlying method representation.
   *
   * Allow to map the variable access with the respective get method.
   *
   * @param  string $name the property name to access
   * @return mixed value depending on the underlying method called
   */
  public function __get( $name )
  {
    $method = 'get' . $name;
    if ( ('mapper' == $name) || !method_exists($this, $method) )
    {
      throw new JLoe_Model_Exception( 'Invalid property' );
    }
    return $this->$method();
  }

  /**
   * Map variable access onto the underlying method representation.
   *
   * Allow to map the variable access with the respective set method.
   *
   * @param  string $name the property name to access
   * @return instance of the inherited class
   */
  public function __set( $name, $value )
  {
    $method = 'set' . $name;
    if ( ('mapper' == $name) || !method_exists($this, $method) )
    {
      throw new JLoe_Model_Exception( 'Invalid property' );
    }
    $this->$method( $value );
  }
}

And with this, you can code your model class with just a few lines. Here goes a sample.

class Quot_Model_Quote extends JLoe_Model_Object
{
  /**
   * Quote id.
   *
   * @var int
   */
  public $Id;

  /**
   * The quote
   *
   * @var string
   */
  public $Quote;

  /**
   * Tags for this quote.
   *
   * @var array
   */
  protected $_tags;
  public function getTags() { return $this->_tags; }
  public function setTags( $tags )
  {
    // Put your own logic here
    $this->_tags = $tags;
  }
}

Here if you wish to allow other class to access it via its variable name, getter, or setter functions, you just need to declare the variable as public as depicted on line 8 and 15. On the other hand, if you wish to limit access to a variable, you can always declare the variable as protected and create your desired getter or setter functions associated with the variable as shown on line 22 to 27.

And now you may access the class as follows.

$quote = new JLoe_Model_Quote();

$quote->Id   = $id;
$quote->Name = $name;
$quote->Tags = $tags;
// You may also use this
$quote
  ->setId( $id )
  ->setName( $name )
  ->setTags( $tags )

$id   = $quote->Id;
$name = $quote->Name;
$tags = $quote->tags;
// Similar with
$id   = $quote->getId();
$name = $quote->getName();
$tags = $quote->getTags();

It’s that easy. Now I can write my model class quickly and easily for other PHP projects. Yey!

In software, testing is clearly necessary to deliver a good product or solution to make your clients or bosses pleased and satisfied with the product. As a developer, I have no experience at all hence have no clue where to start and how to begin with. So again, I have to use my googling skill to look for some clue out there. Please read on and I hope I can help you understand abit.

First you need to understand the difference between Black box and White box testing. This isn’t about the colour but rather to the ideology of the testing. Here’s the definition of Black box testing taken from wiki.

Black box testing takes an external perspective of the test object to derive test cases. These tests can be functional or non-functional, though usually functional. The test designer selects valid and invalid inputs and determines the correct output. There is no knowledge of the test object’s internal structure.

This means that the purpose of the testing is merely to simplify your testing process by specifying input and expecting some output without any knowledge of the what the function is supposed to do. Think of black box as opaque box or closed box. To help you better understand, imagine you are testing an electronics system and it is housed in a black box with lights, switches, and dials on the outside. You must test it without opening it up, and you can’t see beyond its surface. You are only able to see if it works just by flipping switches (inputs) and seeing what happens to the lights and dials (outputs). On the other hand,

White box testing uses an internal perspective of the system to design test cases based on internal structure. It requires programming skills to identify all paths through the software. The tester chooses test case inputs to exercise paths through the code and determines the appropriate outputs.

People refers white box testing to clear box testing, glass box testing, transparent box testing, translucent box testing or structural testing. An opposite test approach would be to open up the electronics system, see how the circuits are wired, apply probes internally and maybe even disassemble parts of it. White box testing may also refer as unit testing, integration testing, or system testing.

First statement in your mind may be “Ok, I get it now” but the question still remains “How do I test?”, “Where should I start?”. Next what you need to do is to gather your customer’s requirements and use them to produce your test cases. A test case is a set of conditions or variables under which a tester will determine whether an application or software system meets documented specifications or requirements. After the list of test cases are produced, testing is then performed based on the list. To help you with test cases, you may refer to this site which provides a good sample of test cases.

There are two approaches in performing your testing: Manual and Automated testing.

Manual testing is is the process of manually testing software for defects. It requires a tester to play the role of an end user, and use most of all features of the application to ensure correct behavior. To ensure completeness of testing, the tester often follows a written test plan that leads them through a set of important test cases.

Whereas Automated testing is the technique of testing software using software rather than people. A test program is written that exercises the software and identifies its defects. These test programs may be written from scratch, or they may be written utilizing a generic Test automation framework. As it is considered to be a very expensive technique hence it requires careful planning and effective testing strategy as explained in “Best Practices in Software Test Automation“. I.M. Testy also highlights that the goal of automated testing has to be Specific, Measurable, Achievable, Realistic, and Timely (SMART).

If you find this post useful, please leave your rating below. Or if you still have doubt, leave your comment below. Thank you!

Sources:

• What is black box/white box testing?
• Five Ways to Think about Black Box Testing
• Test Focus: This site contains some usefull featured articles about testing.
• I. M. Testy : What’s your test automation strategy?