Finally I came to the conclusion that the tests weren’t the problem; it was the XML files that tests were producing. They were simply just too large for the junitreport task to handle. In my application, I was using JUnit to run many tests that for the most part relied on the database. This caused Hibernate to output tons of information to the system out which is then logged in the JUnit report XML. So, as you have already guessed, we have to prevent output from entering the XML or disable logging for hibernate.

Solution:

outputtoformatters=”false”

Looking at that image at first glance, I am just wowed, because I am thinking that Mozilla has been hiding this massive project behind the scenes and the web is finally ready to revolutionize. That is, till I realize that it is just what they HOPE the application to have the capability to do in the future. Of course, given the technology that it is built-on (the browser and JavaScript), I am certain it would be possible given some airline company provides the API to do so, though who knows how long that will be.

Going beyond this unimportant image, I was a bit disappointed that this is tied to the browser and not an independent application. I suppose from Mozilla’s perspective, they already have cross-platform technology to build on (FireFox), so it wouldn’t make sense to create a new application for each operating system. However, from a consumers perspective (in my opinion), it has no business in a web browser. I say that, not because I am anti-browser (I love FireFox), but I feel this type of user interactivity is best suited for what some would call the Web 3.0 movement. A movement in which data follows very strict standards and semantics, is openly available, and can be retrieved beyond that scope of a web browser. 

Expanding on that, I feel as if the future of the “web browser” isn’t far from being extinct (far being around 20 years). I guess I am starting to go on my usual tangent, however I picture the web being able to DO what the user wants; not FIND what the user wants. A concept that is embraced by Ubiquity but the way it is executed is not how I envision. We are decades off from being able to have conversations with our computer but giving it the ability to translate what we tell it in our language and execute those actions is certainly a good start. My only problem with how Ubiquity implements it, is that it relies on the browser. FireFox, as amazing a tool or platform it may be, invests on the principle that the browser is the way users will access information on the internet. I’m sure years from now, this application will just be a small stepping stone to the larger picture, however I would have much rather like to have it built upon the operating system (I’m just in love with Mac OS X’s spotlight feature).

Maybe I’m just a “hater” or it is just to early to judge the success of Ubiquity, who knows. But overall I am just not too impressed because it isn’t as innovative as I thought it would be when I first came across it. Yes, it is pretty cool that it is easily expandable with just a few lines of JavaScript, but I think that is also it’s “ball and chain”. I certainly won’t turn down using it with FireFox and might even write a couple commands of my own, but I would have at least like it a little more integrated into the browser than just a popup on the screen.

What do you think?

Extend core PHP functionality

Previous to the inclusion of namespaces, there was no ability to create custom functions that had the same name as existing functions in the core of the PHP distributions. The concept known as “Global space” will allow a developer to override core functionality which can prove to be very useful.

namespace File;
 
function file_put_contents($file,$data) {
	if( strpos( $file,'ftp://') ){
		// do ftp operation
	}else{
		// will access the core PHP function
		$f = ::file_put_contents($file,data);
		return $f;
	}
}

In that example, I can extend the functionality of file_put_contents to also provide FTP uploading if the path string contains the text “ftp://”. When used within the same namespace, just calling file_put_contents will give you the updated functionality. However, when used in a different namespace, you will have to access it a bit different.

use File;

File::file_put_contents('ftp://localhost/dofile.txt','my content');

Since my transition from PHP to Java, I have started to like the way packages work and would like to see the ability to “use” namespaces and not have to reference the namespace when calling a function from a different namespace.

Overall, this release has brought a lot of needed features (all of which you can probably read up on elsewhere or just hit up the PHP docs) and I am glad to see PHP is moving in the right direction. Looking back, I had a tendency to want PHP to include features found in other languages however I think doing so would alter the direction that PHP has tried to take and perhaps its implementation is the best move to make for both backwards compatibility and expandability while keeping its rapid-development goal.

At first, I thought it was kind of stupid that people would just post what they are doing all day on the internet, but after everyone gave their reasoning for using it, it all started to make a bit of sense. The most compelling reason I heard was that people used it to keep track of things their friends do so they can have a topic for discussion the next time they meet. Besides the social networking aspect of it, it helps save those moments of complete silence when you meet up with people.

Another topic that sparked some interest was a self-organization method known as GTD (Getting Things Done). I’ve find myself over the years having constant memory problems, especially when it comes to remembering tasks to do for projects. Though the idea of keep track of tasks isn’t a new or revolutionary concept, the process this method encourages seems to be better then ones I have tried in the past.

All in all, I met some great people at the event and look forward to picking their brains over tweeter. TWEET TWEET!

Look what I won:

Topics we discussed:

• GTD (Getting Things Done)
• SeaSide Framework
• Podcasting
• Advanced Javascript
• Microblogging
• Amazon Web Services
• Agile
• Language Architecture
• Network Monitoring
• REST API
• YUI (Yahoo User Interface Library)
• Entrepreneurship & Consulting
• Ruby
• Fitnesse Testing
• Content Management

public class MyBean {
	public String getStreamFile(){
		byte[] file = new byte[]{};

		FacesContext ctx = FacesContext.getCurrentInstance();

		HttpServletResponse response = (HttpServletResponse) ctx.getExternalContext().getResponse();
		response.setHeader("Content-disposition", "attachment; filename=file.ext");
		response.setContentType("text/plain");

		try {
			response.getOutputStream().write(file);
		} catch (IOException ex) {
			return "go_to_an_error_page";
		}

		ctx.responseComplete();

		return null;
	}
}

When the user selects the link, either the file will be streamed to user so they may download it, or they will be redirected to an error page. You could go one step further and implement a messaging system or use the one built-in with JSF and redirect the user back to the page they attempted to download the file from.

	// Setup connection
	Properties props = new Properties();
	props.put("mail.smtps.auth", true);
	//props.put("mail.debug", true); // uncomment to display in console/log

	Session session = Session.getInstance(props);
	//session.setDebug(true); // uncomment to display in console/log

	// Setup message
	Message msg = new MimeMessage(session);
	msg.setFrom(new InternetAddress("your@email.com"));
	msg.setRecipients(Message.RecipientType.TO, new InternetAddress[] { new InternetAddress("their@email.com") });
	msg.setSubject("My Subject");
	msg.setSentDate(new Date());
	msg.setText("my message");

	// Connect and mail
	Transport transport = session.getTransport("smtps");
	transport.connect("smtp.gmail.com", "username", "abc123abc");
	transport.sendMessage(msg, msg.getAllRecipients());
	transport.close();

With Attachment

	// Setup connection
	Properties props = new Properties();
	props.put("mail.smtps.auth", true);
	//props.put("mail.debug", true); // uncomment to display in console/log

	Session session = Session.getInstance(props);
	//session.setDebug(true); // uncomment to display in console/log
	// Setup message

	Message msg = new MimeMessage(session);
	msg.setFrom(new InternetAddress("your@email.com"));
	msg.setRecipients(Message.RecipientType.TO, new InternetAddress[] { new InternetAddress("their@email.com") });
	msg.setSubject("My Subject");
	msg.setSentDate(new Date());

	// Begin attachment
	MimeBodyPart attachment = new MimeBodyPart();

	// Add file to attachment (replace with an existing byte array)
	attachment.setDataHandler(new DataHandler(new ByteArrayDataSource(new byte[]{},
			"text/html")));
	attachment.setFileName("test.html");

	// Create normal email message
	MimeBodyPart text = new MimeBodyPart();
	text.setText("my message");

	// Add attachment and message to email
	Multipart mp = new MimeMultipart();
	mp.addBodyPart(text);
	mp.addBodyPart(attachment);
	msg.setContent(mp);

	// Connect and mail
	Transport transport = session.getTransport("smtps");
	transport.connect("smtp.gmail.com", "username", "abc123abc");
	transport.sendMessage(msg, msg.getAllRecipients());
	transport.close();

Databases:

• Tables are lowercase and singular and separated by an underscore.
  This prevents confusion both during coding and managing the database. A lot of languages and frameworks are case sensitive and lowercase is the easiest method to remember.
  "user" instead of "Users", "users", "User"
"user_role" instead of "userRole", "userRoles"
• Fields are lowercase, singular, and separated by an underscore.
  Fields are easier to read when their words are separated by a character. One reason for not using spaces are because they add more syntax to a typical query (ie: SELECT`first name` vs SELECT first_name ).
  "user_id" instead of "userId","user-id","userID","UserID","UserId"
• Association tables begin with parent and end with child
  There may be instances where an association does not involve a parent and a child, so you must use your best judgment.
  "vehicle_car" instead of "car_vehicle"
• Do not use numbers
  You should never have to use numbers in the field name. Perhaps “address1″ and “address2″ are acceptable exceptions (because they are used in real world, however adding “address3″,”address4″ are unneeded and probably mean you need to store addresses in a separate table).
• Primary key should end with “_id”
  Most of the time, you will begin with the table name and end with id. Makes joining tables together simpler because you will always know what the primary key is.

Programming:

• Variables are camel case with meaning or with comments
  Example: If using “roll” in a loop, either keep the loop small or commented to explain what the rolling value will contain or use something more verbose such as “numberEntriesAdded”.
  • Acronyms are lowercase (”getXmlDocument” instead of “getXMLDocument”).
  • If you find yourself having to place numbers in variable names, your code is either redundant or hard to read.
  • Private class variables should be prefixed with a “_” ( “_privateVar” instead of “privateVar”).
• Classes are uppercase without separation
  "MyNewClass" instead of "mynewclass","my_new_class"
  • Constants are uppercase with separating underscores.
    "MY_CLASS_CONSTANT" instead of "my_class_constant","MYCLASSCONSTANT"
• Methods are camel cased without separation
  "executeMyMethod" instead of "execute_my_method","ExecuteMyMethod"
  • Name contains at least an action, object, and value/field
    action: get,set,increase,decrease,add,subtract…
object: car,row,page,template…
value/field(if applicable):width,pixels,id,name

1. Rename the file from foo.html to foo.php
2. Place the contents of foo.html into one huge string and print/echo it.

I cannot believe I didn’t think of this myself.

max_allowed_packet=10M

The maximum value you may specify is 1GB however setting it to a high amount (ie: 250mb), will not cause any performance issues because MySQL will only use that much if necessary.

NOTE: Make sure you have enough memory on your system to handle the increase in packet size or else you could potentially use swap space thus decreasing the performance of the query.