What’s so good about it?

• Design
  Personally I prefer something that is simple and not over the top. And
  the design of this keyboard is very elegant. I would go one step further
  to tout that this keyboard

• Form Factor
  It looked great. The key size feels right, the space between the keys is also good. The arrangement of the key is arguably one of the best I’ve used so far. (I’m a programmer, believe me I’ve used heaps of keyboard before).
• Comfort
  All in all, this is the most comfortable keyboard I have used so far.
• Backlighting
  Since this is the Logitech Illuminated keyboard, I thought I should touch on the backlighting. Logitech have done an awesome job here – the lighting on all keys are perfect, the etching on the keys are very precise and the letters are big and legible. On this department, I have nothing to complain about.
• Durability
  I will tell you in about 5 years whether this is a worthwhile investment or not

What’s bad about it?

• Price!
  Let’s put it this way. I used to think that Apple’s keyboard is the
  winner in all department compared to other keyboard you find on the
  market these days. It’s comfortable, it looked good, and it’s got that
  USB port on the side (that I never really use because it’s slow). This
  keyboard is a big step forward from the Apple keyboard, it is
  comparatively better in every respect – unfortunately it’s also way more
  expensive.

Does it work with Ubuntu?

Yes it does. I plugged it in, and
it worked, period. I am still on Ubuntu 9.10 – but I imagine the support
on 10.04 would be better still.

Conclusion

You do think about
whether something so simple should cost so much or not. I used to be a bit of a skeptic too but once I used this, I can see where all my money went. Whether you splurge for something you type on everyday or not is really up to you

It is common practice for Oracle stored procedure to pass cursors to calling client. The client then needs to guarantee that the cursors are handled and closed properly, otherwise overtime the open cursor will accumulate into an ORA-1000 error (“ORA-1000 Maximum Number of Cursors Exceeded”)

In Java world, cursor translates as ResultSet. In the case where an open cursor is passed from a stored procedure to a Java code (over JDBC), the code must work with the ResultSet and not forget to close() it after it’s done with it. However, this is often overlooked, because when ResultSet is garbage collected, the close() is not called and as a result, the open cursor remains open in the Oracle server.

This fault is surprisingly common amidst Java programmer – and the reason is because inexperienced Java programmers are usually spoiled by Garbage Collection, and many of them failed to develop the strict habit of clearing resource after they are used.

Therefore, Java programmers should always remember to explicitly close() any resource that is explicitly open such as file, and in this case, Oracle database cursors (ResultSet).

Example

This is an example of stored procedure using cursor:

PROCEDURE A_PROC(P_1 IN VARCHAR2, P_OUT_VAL OUT SYS_REFCURSOR) IS
    -- body of execution ---
    OPEN P_OUT_VAL ...
    -- exception handling --
    EXCEPTION WHEN OTHERS THEN
    -- don't forget to close cursor here
END A_PROC;

on stored procedures that passes cursor to the client, it is important to first agree on the way cursors will be handled on exception cases. The best case is usually for the stored procedure to close all open cursor that it can close in the case of exception. In the case where open cursor is successfully passed, the Java/JDBC code need to handle it like so:

CallableStatement cstmt = conn.prepareCall("SQL...");
ResultSet rs = null;
try {
   rs = // obtain result set here
}catch(Exception ex){
   // handle exception here
}
finally{
   // ensure result set (cursors) are closed
   rs.close();
   // ensure statement is closed here
   cstmt.close();
}

Offline ResultSet

What if you need to use the result set outside the context of the operation? Then use CachedRowSet – Oracle provide a concrete implementation that will work fine, called OracleCachedRowSet. Like so:

// this is where the live cursor is
ResultSet rs;
// define offline container & populate it.
CachedRowSet crs = new OracleCachedRowSet();
crs.populate(rs);

But beware:

• ResultSet can be huge, CachedRowSet is convenient but beware of extracting too many data into the cached rowset. That cache lives in memory, don’t blow it out.
• ResultSet resource lifecycle still need to be maintained as per usual, close if when you’ve done reading.

Corner case: Cursor Spike

It is also possible to encounter ORA-1000 error when a JDBC Connection (Oracle Session) is shared amongst multiple thread of execution. A cursor limit is usually imposed on a given Session – sometimes it is possible that due to high usage of the shared session, the cursor ‘spikes’ and exceeded this limit.

This will give a false impression and could cause database developers and JDBC developers to go round chasing the cause for days, while in fact it is not a code problem, but rather session capacity / provisioning problem.

The solution to this is to implement good logging in both end (JDBC & DB side) to isolate the cause, working with DBAs to categorically record session usage and seeing patterns in which the session is being used.

The ideal solution is to control the Connection sharing via Connection Pools.

this is a very good way of capturing notes on the go. This is done through an application called MaStory. Seriously, is there anything this phone can’t do!?

Btw I am gathering notes on n900 configuration. It will be one hell of a guide once it’s done.

Every entity in this world will go through this cycle of living and dying. Nothing shall escape it.

This applies to the most obvious entity of all, our own self. However this also applies to other concept in life. Take for example, a computer system.

A computer system is often the result of a software project. There is the moment where an idea is being formulated, a prototype is built to pitch the project, budget acquired, team formulated and grown, and finally, the project took off (birth). Over time, the system is crafted, again and again it is perfected, broken, fixed, patched, deployed. installed, broken again, fixed again, and so on (aging).

However, as software system changes hand from one team to another, fixes and enhancement done to it may or may not be in accordance with the original structure conceived by its creators. This will eventually result in various internal complication and inconsistencies. Sometimes it is not the software that age, but the hardware. Disks failing, cables aging, memory corruption, dead power supply, and so on. Indeed, nothing last forever! (sickness).

Finally, at some point, all software system will be retired. It may became obsolete, replaced by a newer system, or simply, broke down (death). On that fateful day, management, end-users, or whoever it is that work closely with the system will eventually look back and reflect upon the value it has contributed to the organization or end users. Even future systems implemented will be measured, directly or indirectly, against its older counterparts.

Therefore for those of you who works in the realm of computing, do keep in mind this principle. Take it to your heart that nothing in this world is permanent.

In doing so, when crafting and scoping a system, it is important that we ask ourself (and the client) – what is the intended lifecycle of this project or software system? how will it be supported and maintained? who will look after the system when your team is gone?

Remember that a software system is an entity as much as you are. How you write each of your system reflects your view and life-state in general. And verily so, you can infer the character of a programmer from a piece of code that he has written. From the various decision points he made which is visible in the way the system is structured, organized, partitioned and optimized.

Have that system lived a life worth living?

Well, have you?

Indeed it is true that truth emerges and lies stripped bare when one reflects upon Death. When the system has reached the end of its live, and your name written as craftsman of that system in the various source code and documentations that surrounds the system, how would you like to be perceived?

So if there is one credo for a programmer to follow, this would be it:

Live a life worth living – Craft a system worth crafting.
The two goes hand in hand.

Similar to feature found in the desktop proxy product CCProxy.  The following is the squid base configuration  for such a proxy. As usual, replace $VARIABLE with its corresponding values directly in the configuration file.

# port to use
http_port $SQUID_PORT
 
# upstream BASIC authentication
cache_peer $PROXY_HOST parent $PROXY_PORT 0 no-query default proxy-only login=$PROXY_USER:$PROXY_PASSWORD
 
# ACL
 
acl manager proto cache_object
acl localhost src 127.0.0.1/255.255.255.255
acl all src 0.0.0.0/0.0.0.0
 
http_access allow all
never_direct allow all
icp_access deny all
 
# LOGGING
cache_log $LOG_DIR_PATH/cache.log
cache_store_log $LOG_DIR_PATH/store.log
 
#caching
cache_dir ufs $CACHE_DIR_PATH 10 1 1
 
#cache_effective_user squid
#cache_effective_group wheel
 
#no local caching
maximum_object_size 0 KB
minimum_object_size 0 KB
 
# specify uncachable requests
acl all src 0.0.0.0/0.0.0.0
no_cache deny all

The note covers all of the steps I discovered in setting  up and configuring Linux Ubuntu 9.10 to be the perfect desktop OS. This include pointers on setting  up disk partitions, installations, compiz configuration, and more. Best enjoyed in full screen ( to see the details). Song is from Coldplay

Have fun

Example: tenthargs.sh

#!/bin/bash
echo "$1 $2 $3 $4 $5 $6 $7 $8 $9 ${10}"

When invoked:

$ ./tenthargs.sh one two three four five six seven eight nine ten
# properly prints out:
# one two three four five six seven eight nine ten

if $10 is used instead of ${10}, upon running the result will be like this instead:

# one two three four five six seven eight nine one0

That is, bash understood $10 as the first parameter ($1) followed by a literal 0 instead of the ‘tenth args’.

Of course, I have added this to my bash notes.

Roundup, as you may already know is a Python issue tracking system. zroundup stands for zero configuration roundup – I’m aiming to make an issue tracking system that you can just download and run. Preferrably I would also like to be able to put this into a thumbdrive and then carry it around with me – a portable issue tracking system, on a stick!

I actually thought that this sort of thing would be perfect for freelancers / contractors who are usually on the move and have a huge list of issues / tasks on multiple projects that need to be managed.

Note: Probably you’ll have to see this in full screen, I haven’t figure out how to take a screenshot of only the region within my desktop, and keep in mind that this is still a work in progress – when it’s finished, the use case would likely be:

• Download and install on a USB stick
• You can run / stop the issue tracker from the USB stick
• If you disconnect the USB stick the tracker will stop, but preserving all data
• If you connect the USB stick on a windows machine, the tracker will run (automatically, if autoplay is enabled).

WordPress, the blog engine

WordPress by itself provides the full feature as-is. Even the ones in wordpress.com allows you to use all of its feature.

• Plugins and Themes requires you to upload the file into the wordpress installation directory. As far as I know, you can’t do this in wordpress.com, because you don’t have a ‘server shell account’ that you can use to log into the file system and upload your stuff in there.
• You can choose one of the default themes and modify them, but you can’t upload your own graphic/image in there. You can only link out to images available on the net. In short, it’s painful.

Hosting wordpress outside wordpress.com

• To host a wordpress blog outside of wordpress.com, you need Apache, MySQL and PHP. In other words you need a web server with PHP and MySQL backend.
• If you want to keep it simple, I suggest you find a free web hosting that supports PHP, MySQL and (S)FTP.
• Dump wordpress in there and play around.

Paid hosting and domain name

• Once you are comfortable working with WordPress and you feel confident enough to take the plunge, you may subscribe to a paid hosting server for more support & reliability (most hosting cost aroun $5-10 USD per month)
• Copy your wordpress installation into this paid hosting.
• Afterwards, you can also migrate the content of your blog from one wordpress installation to another easily with its export/import tool.
• Once you have your blog up and running, you can get domain name (e.g. www.mydomainNameIsCoolerThanYours.com) and have it point to your existing wordpress installation on your paid hosting service. Check out GoDaddy.com for domain name registration (costs you about $10USD per year)

If you are geekier than the rest

• If you just want to play around & experiment, you can download WAMP and install it in your PC, then put wordpress there. Since that is in your PC you can experiment as much as you want and do whatever you like.
• This is more relevant for people who wants to do Theme development, plugin development, and the like.

If you are thinking of going more hardcore on WordPress blogging, I hope this will help point you in the right direction.

Notable feature:

• Can be activated via keystroke or mouse gesture. The mouse gesture never really work for me, but the keystroke is great
• Customizable look and feel, you can even set a wallpaper for the tab switcher
• Customizable tab switching animation, which include ‘cover flip’ ala iTunes album selector

Yet another reason to stick with Firefox