Hoping that it could be useful for anybody else that frequently finds themselves in a “friend / relative / XXX” who is a “computer guy / gal “ kind of role, and who is expected to easily and quickly solve any computer related task, here goes one possible quick and simple solution for building the aforementioned portfolio site.

Building a portfolio website is certainly not the most complex of I.T. tasks nowadays, however, the constraints surrounding my business case did make it quite challenging:

• My knowledge on Web Design and Website construction has not advanced since the early 00’s (CSS effects, Flash and HTML5 remain quite a mystery to me)
• The total cost of construction / hosting….and anything else, must be 0
• No ugly side effects of free hosting (such as popups) are allowed
• The portfolio must allow easy album management: uploading, coding and any other technical aspects are to remain transparent for the end user

Transparent Album Management

The most challenging requirement for me was to find a solution that offers easy and trivial album management.

FTP Uploading, remote directory creation or html coding were definitely out of the question, as all these tasks require specific knowledge that could not be imposed on the end user.

Fortunately enough, I stumbled upon Jalbum.

Jalbum offers free hosting for photo albums and, more importantly, jalbum also offers a great java client application that allows the user to easily create and manage the photo albums of their site.

Clicking, dragging and dropping are the only three basic operations needed to successfully use jalbum.

The client is freely downloadable, and it is possible to have a nice ad-free, popup-free 30 mb (more or less 200 photos, which is enough for the business case) account for free.

Custom and “nice looking” Portfolio Website

The business case required a nice flashy home page, and a top menu to connect the different albums.

Flash Catalyst came to the rescue when my complete ignorance of flash became a blocking issue towards providing a simple animation for the front page.

Although a bit buggy (perhaps due to the fact that it was still in a beta phase when I tried it), if equipped with a nice layered PSD, it is extremely simple to create nice flashy animations.

(Ryan’s “Geting Started with Flash Catalyst” tutorial should get you towards the path of simple animations in only a couple of hours)

(As a side note, sadly enough, I had to find a Windows PC to use Flash Catalyst: the prerequisites state that “cannot install on a volume that uses a case-sensitive file system”, which unfortunately is the (bad?) choice I made when installing MAC OS…. Maybe something to be solved in the future?)

After fiddling around with Jalbum’s skins, I managed to modify azarai’s great Imago skin, inserting the different top menus, allowing for the desired effect of linking the albums together on one site.

Hosting

Jalbum’s hosting is not intended to allow for flexible and custom websites, but rather only for hosting of jalbum-friendly sites, which meant that it was not possible to host the front page together with the jalbum photo albums.

The last time I had searched for a nice free clean hosting solution, I believe the now extinct Geocities was the best choice, which can give an idea of my knowledge on the current state of free hosting possibilities.

After some googling, I ended up setting up a Google App Engine account.

This option offered more than needed, and after downloading the SDK, creating my project and a simple “../appengine-java-sdk/bin/appcfg.sh update war”, the portfolio was up and running in the cloud.

I have to say, that I consider the final result to be not bad for a 0-cost-sunday-morning-built portfolio…

Although cheaper and more limited (functionality wise) models can be found, the eTrex Venture HC is great value for money.

The 10.000 point logging capacity, excellent reception and 14 hour battery life, and the Garmin Mac-friendly software utilities, were enough to convince me.

With Road Trip for example, it is possible to export recorded data in GPX format.

One possible source for such information is, for example, a GPS data logger.

The path from GPX to Google Maps can be completed in 3 simple steps:

1. Export the recorded tracks to GPX

In my case, with the Venture HC, it is quite simple.

Connect the Venture HC to the Mac through the USB port, turn it on, fire up Road Trip and click on the “Receive” button. The recorded tracks should appear in the “Recently Read” folder. Simply copy the needed tracks into a created folder and then export the folder.

2. Convert the GPX file to KMZ

KMZ files are zipped versions of KML files, which is another XML based standard for representing GPS data.

In any case, the KMZ format is a format that Google Maps understands, so the GPX must be transformed to this format, with GPS Visualizer, for example.

3. Code the Map

Couldn’t be easier:

    if (GBrowserIsCompatible()) {
      var map = new GMap2(document.getElementById("map"));
      map.addControl(new GLargeMapControl());
      map.addControl(new GMapTypeControl());
      map.setCenter(new GLatLng(49.613824,6.127625), 12);
      var kml = new GGeoXml("http://dvrom.eu/bike/2.kmz");
      map.addOverlay(kml);
    }

And, the final result, for example, a bicycle route around luxembourg.

The hard part of all this is producing relevant input data….in some form of physical activity, of course…

Video

	1) Connect 360 Stream audio (iTunes) and video (anything playable on your Mac) directly to your Xbox 360.
	2) VLC This great video player works just as well on Mac OS X as it does on other platforms, and is able to play just about every video format out there.
	3) ffmpegX Nice little video and audio encoder, great for embedding subtitles directly in the video for example.
	4) DivX for MAC The DivX origin story is quite interesting, and the codec itself is still widely used.
	5) MPEG Streamclip Another great tool for encoding, decoding and authoring video.
	6) Flip4Mac Allows to play Windows Media Video and Audio files on Mac OS X (also embedded WMV in web pages).

Blogging Tools

	7) Cyberduck A great lightweight ftp client.
	8) TextWrangler A great text editor, with syntax highlighting.
	9) GIMP Although I never liked the multi window GUI, It’s definitely the best free graphics editor, and it can run on X11 on Mac OS X.
	10) MAMP The easiest way to get a Apache - MySQL - PHP test environment up and running on a Mac.

Geolocation

	11) Exif Viewer A nice little tool to view the EXIF information of a image file.
	12) Geotagger Works in combination with Google Earth to offer manual geotagging of image files.
	13) GPSPhotoLinker A tool for automatically geotaging photos by reading previously saved geolocated logged data.

Other Niceties

	14) XCode Apple’s developer tools, and, amongst other things, the easiest way to get gcc on Max OS X.
	15) NeoOffice Based on OpenOffice, but runs slightly faster.
	16) Little Snitch An excellent (and above all discrete and not annoying) network monitor. Great for keeping an eye on what you are letting in and out.
	17) MenuMeters A nice little system monitor that sits in the menu bar, allowing to get info on network, cpu and memory usage.
	18) UnRarX Mac OS X can not handle rar files out of the box, so UnRarX can be very useful.
	19) utorrent The best lightweight torrent client.
	20) NTFS-3G Enables write operations on NTFS filesystems on Mac OS X. Specially useful if dual os’ing.

1. Download and install GIMP

2. Open Image

3. Filters -> Light and Shadow -> Drop Shadow

Simply:

1. Install ImageMagick

2. Setup the needed environment variables:

export MAGICK_HOME="/opt/local/var/ImageMagick-6.5.3"
export PATH="/opt/local/var/ImageMagick-6.5.3/bin:$PATH"
export DYLD_LIBRARY_PATH="/opt/local/var/ImageMagick-6.5.3/lib"

3. Resize:

bash-3.2$ /opt/local/bin/mogrify -resize 525x700 image.jpg

(NOTE: Overwrites image (does not create a new image))

Every software project is different, and has it’s own and unique needs, and as Edward Garson points out in Context is King:

“I feel there is a certain irony in trying to impart something about architectural ideals, when the very premise I wish to begin with is that effectively there are no ideals. If this is indeed the case, then surely there is nothing to write, I am a contradiction and by doing this I run the risk of the universe imploding or something like that.”

However:

“But alas, ceci n’est pas une pipe.”

I also believe that software engineering projects do share some common issues (or at least I hope for this, any morale booster is welcomed: software engineering is such a challenging discipline that despair is frequent !).

“97 Things” points out some topics and solutions that should probably be applicable for any software engineering endeavor.

There are some big names and many years of experience behind these tidbits of wisdom, and in my short career so far, I have found many of the described issues in “97 Things” in past and present projects.

Because 97 things are too much for my short term memory, these are the top 3 things to know that I strive to remember:

1. Choose the most adequate technology

Very often, the technology chosen to solve a certain problem is not the optimal solution.

As stated in Don’t put your resume ahead of the requirements, sometimes technologies are chosen just because they are “newer than” or “cooler than” other technologies that would be more adequate.

In other cases, the same technology is used over and over again. There is no one-size-fits-all solution. In most cases this is caused by one of the greater dangers in software engineering: prioritizing component/architecture/code/design reuse over any other criteria. In many cases, the business case is adapted to use an existing solution, when it should be the other way around. I have not seen worse evil than corporate frameworks !

We should probably ”think outside the stack” more often, and choose the best solution for each problem: Heterogeneity Wins.

2. KISS and YAGNI

“Keep it Simple, Stupid” and “You Aren’t Gonna Need It !” are two principles that aim to solve one of the most frequent pitfalls I encounter: unneeded complexity.

In Simplify essential complexity; diminish accidental complexity Neal Ford’s explains this error (in a developer context) perfectly:

“Developers are drawn to complexity like moths to flame, frequently with the same result. Puzzle solving is fun, and developers are problem solvers. Who doesn’t like the rush of solving some incredibly complex problem? In large-scale software, though, removing accidental complexity while retaining the solution to the essential complexity is challenging”

He also adds:

“Look at the percentage of code you have in a solution that directly addresses the business problem vs. code that merely services the boundary between the application and the users”

Know when to stop (“Perfect” is the Enemy of “Good Enough”), Don’t Be Clever, Make sure the simple stuff is simple and remember that You can’t future-proof solutions, that Application architecture determines performance and that Scope is the enemy of success !

3. Know the business case

If you Understand The Business Domain and realize that Context is King, you should be able to challenge client-requested system-constraining unneeded requirements and Seek the value in requested capabilities and Quantify fuzzy demands.

Even though Business Drives, if we have enough knowledge on the domain, we can give the client what he needs, not what he wants, because Your Customer is Not Your Customer.

And everything else…

These are just my top 3…but there are many many others.

Online and free…so there really is no excuse not to take a look !

Having encountered this book on many “Top Books a Software Engineer Must Read” lists, I thought i’d give it a try.

This will not be a in-depth review, as there are already many out there, but rather a summary of ideas that will stay with me after this first read.

Michael’s book is all about the problematics related to successfully executing software systems in production, and although it is centered on high availability and large scale distributed systems, many of the discussed topics can be applied to any software system.

The book covers all the possible elements and layers of software engineering I can think of: management, delivery, testing, design, coding…, front-end, back-end, deployment, etc., and rather than trying to answer all the questions, it tries to point out the good direction in which to go.

This is certainly a book that I expect to come back to in the future, as the ideas and scenarios that will stay with me after this first read are only the ones which I can relate to, because I have encountered them in current and past projects.

Stability and Testing

The first part of the book discusses stability, and what should be done in order to achieve a high availability 24/7 system that is able to meet strict SLA requirements.

One aspect that I could relate to, and I found to be of particular interest, was the topic of how to and what to exactly test when assuring the stability of your system.

For example, the book mentions the use of a ”nasty test harness”: Your system should be mistreated and abused in all the possible ways you can imagine.

This is something I encountered in the past: the complexity of some projects made it not feasible to test the complete workflow of all test cases.

Instead, in a reductio ad absurdum style, a certain time frame was established in which the system was punished in order to find a unstable system state.

If it is not possible to test for stability, then the search for instability could help find some weak spots in your system.

Another idea that I can relate to, and which I have witnessed, is that in an EAI / SOA / ESB scenario, where your system is forced to live and communicate with strange and alien systems, every integration point is a major risk in your system stability.

Unit tests, functional tests, integration tests, point to point tests, component tests…etc…all test the system’s behavior under normal or spec conditions, but do you know how your system behaves in out of spec conditions?

In effect, for every integration point, it is important to know what happens to your system if it receives unexpected or inexistent responses.

The same can be said in the other direction: how do the other systems react if your system sends out strange or inexistent responses?

Another topic which I found to be interesting was “Longevity Testing”.

The idea of longevity testing is to have production-like tests run in a production-like frequency against a long running production-like server, in order to detect otherwise undetectable system failures, such as the dreaded OutOfMemory exception (and avoid shameful quick fix production daily server restarts).

Application Monitoring and Resource Use

Having worked in the past in a Winston Wolf role, that is, as a technical consultant, I got to know the hard way just how important it is to be able to easily monitor and diagnose your system in production environments.

Michael’s book highlights this, and points out what vital parts of the system should be monitored.

One topic that is discussed, and that I can relate to, is probably the number one output of monitoring information that a software system in production relies on: logging.

In my experience, each time a real-time debug session is needed to fix a bug, and logging was not enough, a risk emerges: the system could not be telling us something important.

The simple fact of not logging certain information, could make fixing bugs that appear in production a long and weary task: sometimes data exports, message dumps and others are not possible, and reproducing production settings in a development environment for analysis can be a difficult or even a impossible task.

Release it! also outlines how important it is to understand exactly how your system is using resources.

These resources vary from the ”big four” (CPU, Memory, Storage, Bandwidth), to resource pools, threads, database connection pools, and any other resource.

Development and production metrics can help on understanding where our system can break, and even avoid future disasters.

After reading this book, one becomes resource-paranoid, which is probably a good thing.

Every time you will work with a connection pool, set an isolation level, start a transaction, or even set a JVM property, you will probably find yourself wondering what happens to your system if no connection is availablel, if the transaction fails or if your application server dies.

Architecture, Patterns and Anti-Patterns

Another significant topic treated in the book is system architecture, patterns and anti-patterns.

What will stick with me, and which is quite obvious, but I find never to be mentioned enough, is the idea that the more coupled your systems are in your landscape, the more risk for global failure.

And to this I would add, the more systems in your landscape the higher the risk.

The first rule in simplifying an integration scenario is to eliminate systems.

If, for whatever reasons (political and contractual are the most often and most unjustifiable ones) this is not possible, several patterns are presented to avoid tight coupling between systems, and examples of just how one strong dependency can bring down the whole system are described.

Conclusion

Release it! is a great book for people who have some relevant experience in taking a software system to production.

The content exposed is vast enough to be useful in almost any software project, although readers working on high availability distributed systems will get the most out of it.

The book has a wonderful pace, and Michael gives some great real life examples of how systems can break in both a spectacular and frightening manner.

Easy reading and a valuable source of knowledge, not to be missed!

2. Write the code to invoke the REST url through curl, parse the xml, and transform the result into a nice array:

	$ch=curl_init();
	$curl_post_data = array(
		"method" => "flickr.photos.search",
		"api_key" => $api_key,
		"lat" => $lat,
		"lon" => $lon,
		"radius_units" => "km",
		"has_geo" => "1",
		"radius" => $radius,
		"accuracy" => $accuracy,
		"min_taken_date" => $min_taken_date,
		"max_taken_date" => $max_taken_date,
	);
	curl_setopt($ch, CURLOPT_URL, 'http://api.flickr.com/services/rest/');
	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
	curl_setopt($ch, CURLOPT_POST, true);
	curl_setopt($ch, CURLOPT_POSTFIELDS, $curl_post_data);
	$xmlstr=curl_exec($ch);
	curl_close($ch);
	$xml = new SimpleXMLElement($xmlstr);
	$totalresults=$xml->photos['total'];
	$photoresults = array();
	if ($totalresults!=0){
		foreach ($xml->photos->photo as $photo) {
			$photoinfotmp=array();
			$photoinfotmp['id']=$photo['id'];
			$photoinfotmp['owner']=$photo['owner'];
			$photoinfotmp['secret']=$photo['secret'];
			$photoinfotmp['server']=$photo['server'];
			$photoinfotmp['farm']=$photo['farm'];
			$photoinfotmp['title']=$photo['title'];
			$photoinfotmp['ispublic']=$photo['ispublic'];
			$photoinfotmp['isfriend']=$photo['isfriend'];
			$photoinfotmp['isfamily']=$photo['isfamily'];
			$photoinfotmp['url']="http://farm".$photoinfotmp['farm'];
                        $photoinfotmp['url']=$photoinfotmp['url'].$photoinfotmp['server'];
                        $photoinfotmp['url']=$photoinfotmp['url']."/".$photoinfotmp['id'];
                        $photoinfotmp['url']=$photoinfotmp['url']."_".$photo['secret'].".jpg";
			$photoresults[]=$photoinfotmp;
		}
	}

NOTE: For some reason, invoking the REST url with file_get_contents or curl with GET instead of POST was returning incorrect results…

Regardless of the reasons why one would want to know the degree of one’s internet presence, such as ego or curiosity, the idea has come to be quite a common practice, and several terms have even appeared to identify this trend.

New possibilities of querying the world wide web appear at almost the same frequency in which new ways to share information become available, and with the advance of the Semantic Web, it is incredibly easy to explore the web in different ways.

While thinking about this idea, I wondered if it would be possible to “self flickr” myself.

For example, thanks to the flickr API, it is possible to query the flickr photo base in innovative ways, such as integrating flickr content with a semantic web version of wikipedia.

As the moment of this writing, flickr has over 80 million geotagged photos.

I myself have a collection of photo’s that have been geotagged.

Could it be possible to find myself in someone else’s photo, somewhere in the background, inadvertently becoming part of the picture?

For each one of my photos, I created a link that allows to query flickr for photos that were taken at more or less the same time and at more or less the same place.

Timestamp and geolocation information is extracted from each photo, and used as search criteria for the flickr API call.

For the moment, I have not managed to find myself in somebody else’s photo, although results are surprising: some photos were taken at almost the same time and at almost the same place.

In theory, the possibility of finding myself should increase day by day, as users continue to embrace photo geotagging technologies.

Thinking ahead, it should be possible to include other photo sharing sites that offer querying APIs, and thinking even more ahead at a larger scale, one could even consider running queries continuously, and analyzing results with face detection applications for examples…

The question that remains is if all this is just some sort of egolized form of amusement à la Where’s Wally?, or if this and similar ideas is something to bring up next time you run in to some idea-searching VC’s…