I recently had a customer that required a report that could have been generated to HTML or PDF. However, what they really needed was information exported in a specific manner and format from their postgreSQL database for further analysis. HTML and PDF would not have given the flexibility to properly review the data.

Many times I’ve used Microsoft Office with .net products but had not done so with php. Thanks to CodePlex this was a very simple task. I have to say that their interface and methods are so much easier than anything .NET has come up with. There is a great deal of documentation and online information so you aren’t left hanging. I had this set up and creating my first automated excel report in under 30 minutes.

1. Download the latest production version of PHPExcel from http://phpexcel.codeplex.com
2. Follow the installation steps
3. The installation will include a folder named “Tests”. Copy (don’t move) this folder to the directory you run php from. For me it was c:/inetpub/wwwroot/Tests.
4. Try it out…open a browser (I use FF) and pointing to the test directory open the php example 01simple-download-xls.php.

   If you have your computer set up to run php locally under wwwroot, the url would be
      ”http://localhost/Tests/01simple-download-xls.php”

That was it. This folder has all the examples you will need for formatting your spreadsheets. They’ve added some extensive interface support including image placement, text rotation, and security. There is even an extensive manual with all of the methods available, tips on how to best use the methods, and example code snippets.

Unlike the .net approach, PHPExcel goes back to the basic coordinate reference methodology that Microsoft abandoned (for some unknown and definitely not good reason). To do something with the first cell you reference by Column / Row pair. (“A1″) just as you do with VBA. If you are familiar with Visual Basic for Applications, then this code syntax will not seem foreign at all.

Here’s an example of opening a worksheet and adding some text, saving as a tmp, and opening for view


/** PHPExcel */
require_once 'Classes/PHPExcel.php';
// Create new PHPExcel object
$objPHPExcel = new PHPExcel();
$modifiedby = $auth->getUserName();
// Set properties
$objPHPExcel->getProperties()->setCreator("JET Technical, Inc.")
->setLastModifiedBy($modifiedby)
->setTitle('MS Excel by way of PHP')
->setDescription('Opening Excel from PHP');

$objWriter = PHPExcel_IOFactory::createWriter($objPHPExcel, 'Excel2007');
$objWriter->save('php://output');//this saves the temp file


Thank you Code Plex contributors!

This particular subject is quite a hot button with programmers. So use it either as a guideline for your own coding or remember when you’re referring to another programmer’s code that not all great minds think alike!

Response 1

Thanks @Tamara, I just waded past 6 jobs to get to a real discussion.

You’re right… Refactoring is a great way of encapsulating blocks of code that are used more than once… I find it useful for class and implementing algorithms that I need to use in several places.

My unfortunate bad habit is to throw them all into a “growing” helper static class. This is a habit that I need to break… Mind you, its a really really useful static class…

Response 2

I believe it’s okay to throw it out there (just write the code) and then go back to refine “refactor”. Practice and experience will help you get to a point where you recognize what needs to be drawn out up front.

Maintainability, solid foundations, base classes etc… It all makes sense.

So I’ll throw a question out there. What would you consider OVER the top on refactoring? Does it make sense in some situations to have the same function (or functionality) in multiple places? You know I’m finding this more of an art form rather than a hard and fast rule.

When/if you use generic functions, you may find that you can combine several functions together into a smaller set of functions that you will reuse in multiple places.

The function in question used the ability to casting an ExpandoObject to a KeyValuePair collection, and then have the choice of accessing the properties directly (via the expando), or via their name as a string (via the KeyValuePair). Previously, there were functions spread through the code that managed a few properties here and there. With the cast, these bit of code got condensed to a simple set of functions.

Sometimes, the more complex way is better.

Response 4

Just to go back to your original question @Tamara, speghetti code is what I call sticking plaster code. This is code that the developer piles on top of code to quick fix bugs and functionality problems – covering over the cracks rather than restructing (refactoring) the code to do the job. I think you’re right about the skeptical attitude of ‘uniformed’ programmers to refactoring as traditional non-agile development methods really discourage any form of code rewriting. The attitude seems to be, “you have the functional and techical specifications so why can’t you get the code structure right first time”.

To me refactoring is an art form. Its a bit like being a writer who picks over every sentence to create a flowing paragragh. There’s a great deal of satisfaction to be had by creating that elegant piece of code in which every object has a clear function and no code is unnecessarily repeated – SoC & DRY music to my ears . However, unlike art commercials do have an impact and sometimes, as you have both eluded to, its fine to have some rough edges.

Response 5

I agree. Especially in terms of “agile”, “reviewing what can be refactored”, “art form”.

It’s definitely all of the above. One other point I’d like to add as to the benefits is maintainability! I strive for dynamic code that can be used in multiple ways by merely passing a variable. Also, looking at objects and moving repetitive actions to a base object that all can be derived from.

I love cast! if it’s null – then just go on and ignore.

I agree on the rough edges but if you’re working on a large, scalable, enterprise application – they can come back later to really bite you. However, sometimes, the business demands just don’t allow for the time to write clean code.

Getting the structure right the first time takes practice. BUT you have to be willing to practice!

Response 6

Perhaps the most important point that I missed from my previous posting was the need to have error checking built into the code, for example, asserting that method parameters are valid before carrying out the task. As you say @Tamara in a large enterprise application problems really cause issues and if they can’t be traced easily they are very costly to resolve. Code Contract appear to tackle this issue although I do not have any personal experience using them.

Response 7

I like to think that a properly written enterprise application can be easily broken down into smaller pieces without the entire infrastructure falling apart.

Proper refactoring can help here ( my opinion ). But!!!! This brings me back to the original question of how much refactoring is too much and when does it actually turn in to junk?

You know if you refactor it all out to the point where you can’t take individual object out and use as a semi stand alone then don’t you really have a monster made like a jigsaw puzzle with lots of little pieces? And if that’s the case, what has it accomplished?

Some programmers take this to the far extreme where every little bit is placed in library files, compiled and then referenced back in an application. Commonly referred to as “DLL Hell” – something I hope never to experience again.

Response 8

From Wikipedia, a good definition . Spaghetti code is a pejorative term for source code that has a complex and tangled control structure, especially one using many GOTOs, exceptions, threads, or other “unstructured” branching constructs. It is named such because program flow tends to look like a bowl of spaghetti, i.e. twisted and tangled. Spaghetti code can be caused by several factors, including inexperienced programmers and a complex program which has been continuously modified over a long life cycle. Structured programming greatly decreased the incidence of spaghetti code.

Response 9

I just wonder if, following the pasta theme, that we should call over refactored code (as @Tamara describes) as ravioli code – lots of wrapped up pieces floating in a opaque sauce. Sorry it doesn’t take the discussion much further but I think the general point is that over indulgence in refactoring can have the same result as Spaghetti code.

Response 10

If you can’t easily plug in various components into your code, then it’s not decoupled enough – and I’d characterize it as spaghetti code. Pick top 3 functionalities your code does, and ask how easy it is to swap them in/out.

Response 11

Okay, this is fine… We now refactored the code, a few blocks here and there have been replaced with generic functions etc… Along comes the newbie… no idea of generics, LINQ or whatever makes the code better, and lays on another load of “conventional” pedesterian code over our refactored code… What do you do?

Response 12

Hi, I’d like to take a non-technical view on this if I may.

You hired the newbie yourself? Then you certainly shouldn’t make it his problem. There are plenty of companies out there that haven’t reached a certain maturity level and still think they need precisely that kind of ‘pragmatic’ developer. Fast growing startups, for instance.

Either invest in his training and get him up to your standards. Or invite your recruiting officer over for a cup of coffee and explain in great detail what kind of team member you’re looking for. Get all of your processes aligned: business, recruiting, development, maintenance etc. Even marketing, because of the shorter Time to Market.

Why? Because developing structured and maintainable code by applying refactoring will be perceived as a worthless theoretical exercise outside of the development team in the eyes of the unappreciating. Your development team will suffocate while having to justify all that ‘unnecessary’ refactoring at every step of the way.

So unless you get your company’s processes aligned, they’ll just keep hiring newbies. Which means that at some time you should start wondering if it really is the newbie that’s out of place here:-) And to answer Tamara’s question: refactoring won’t cross the line that quickly if – in general – it stays in line with the company’s established processes.

Just a thought…

Response 13

Your first code should follow at least some basic OO principles, writing the same function over and over in spaghetti code or creating god classes is something that isn’t justified because nowadays everyone coming out of college has being taught OO.

With that being said, you should never – ever consider refactoring before you have test coverage over the code you are about to refactor. That means knowing exactly what a class does and understanding it’s purpose, then writing down a full test coverage suite (unit test / integration tests) of the refactored class and making sure that everything passes before and after refactoring.

Response 14

This is a great discussion. My rule of thumb is, when my code is used once, I would keep it “pedestrian” or “spaghetti” style. However, as soon as another chunk of code needs to use the same or even similar functionality, I would refactor it and place it either in an existing class or a new class, depending whether or not the functionality can be grouped with existing class. Now when someone else wrote the code, especially on large applications, this practice becomes more challenging because we’d never know where else a chunk of spaghetti code is used, if it is, unless we review the entire application just like Tamara said in the first place.

This already popular software just got faster to run, easier to use, and with added security.

Coming soon….Online Live Demo

• One document, one storage place, multi-user
• Looks are deceiving…to the user, a window’s explorer but that’s where the similarity ends.
• One document, multi-level security controls
• Document version control
• Platform independent

Contact our sales team for more details

innerHTML is a common way to return the value of an html tag. I was recently working with an AJAX / JQuery application and all was going well. However, the innerHTML method wasn’t returning anything with a textarea tag. All of the other values were coming through just fine with the identical code.

Somewhere in the recesses of my memory I had recalled running in to this in the past (probably blocked out due to the pain!).

Anyway, a quick look on line and I remembered that innerHTML doesn’t work with Firefox. To return the text in a textarea tag, use the value reference instead.

use->  var myText = document.getElementById(‘myTextArea’).value;

ESXI Hidden Service Console

As anyone that has worked with VMware’s ESXI Server they know that the service console has been stripped out (unlike the ESX version). There are many benefits to this – fewer patches, less overhead, and greater security. With ESXI, the “console” as it’s called, is a simple yellow and black menu driven text interface with only the most basic options. However, ESXI actually has a thin linux-based console that can be accessed with a little “know how”.

To get the fine print out of the way:–Officially, VMware says that you should administer your ESXI server using either the GUI VI Client or the CLI VMware RCLI, and you should only be administrating your ESXI server through the Hidden Service Console if you are on the phone with VMware’s Technical support. Because of this, neither VMware nor I can make any warranties if, by using this interface, something unexpected happens to your ESXI Server. Because of that, you should only do this on a TEST system. Ok, now that that’s over, let’s keep going.

There is another CLI interface for ESXI that can be used to run commands directly on the server (the Hidden Service Console. This is in contrast to RCLI where the command is run on your local management PC and connects to the ESXI host over the network. The difference is that with RCLI, you cannot, edit a remote file as you could do if you were using the traditional ESX Server service console.

Because of this, the only way to edit a file like /etc/hosts or /etc/inetd.conf is to access this hidden & unsupported thin linux interface and edit these files with vi. Also, with the ESXI hidden console, you can run commands like esxtop, vmkfstools, and esxcfg-route.

Accessing the hidden & unsupported ESXI console is not difficult. However, if you do not know how to do it, there is no menu option or easily accessed help file that tells you how to access it. (hence the “Hidden” word I keep saying)

To access the hidden & unsupported ESXI console, you must go to the console of the server. You cannot access this console via RCLI, RDP, the VI client, or other method. The only way to access the ESXI console is to go to the console of the server.

Once you are on the server’s console, press Alt-F1.

At that point you will see a console log of what has happened on the server but there is no prompt and no help file available. If you type something, it will not appear on the screen.

Next, type the command unsupported and press enter. Again, this will not appear on the screen.

This activates what VMware called “Tech Support Mode.

Now, type your ESXI Server root password.

At this point, you are successfully logged into the hidden ESXI console.

http://www.kellys-korner-xp.com/xp_tweaks.htm

What is jQuery? If you haven’t heard of jQuery or had a chance to check it out you really should. jQuery is designed to change the way that you write JavaScript.

Using Visual Quickstart Guide’s jQuery book makes things really simple and easy to understand. For those of you who don’t know jQuery is a JavaScript library that simplifies coding a lot. Because of some of the function in the jQuery library code that used to take up a quarter of the page can be simplified into 1 or 2 simple lines. On top of that there are some other really cool features that are a part of jQuery.

One of jQuery’s specialties is letting you select page elements so you can work with them. Selecting page elements is a big part of online work. Until now almost all selection capabilities involved the getElementByID(), getElementsByName(), or some type of for each statement which all work but are limited, time consuming and take unnecessary overhead. jQuery on the other hand goes above and beyond these methods. In jQuery your able to select by descendants, by children, by specific text, by attribute, by attribute value, and even by position all by just one simple line of code changed based on what your selecting.

For example lets say I want select all the elements with a language attribute of Portuguese. In JavaScript the only way to do this would be to add an ID tag on each and every element with the language attribute of Portuguese, which may not seem like that big of deal but if you didn’t add it when you first programmed, it can be. In jQuery all I have to do is add this line of code:

$(‘p[language=''Portuguese']‘)

and then add the function or whatever action I want it to run. While it may not make things shorter it sure does simplify.
One of the most powerful selectors in my opinion is the ‘checked selector, which lets you select checked check boxes and selected radio buttons. Using this you can tell which elements are checked and which aren’t rather than the cumbersome “if value checked or if true” logic required prior to jQuery.
Here’s a quick example:

Function count()
{
alert(“You checked ” +
$(“input:checked”).length +
” items.”);
}

By entering this in a script tag and using the checked selector I can see how many check boxes were selected. The selectors in jQuery make it much easier to work online. I’ve talked about a few selectors here but there are so many more built into jQuery giving you a variety of ways to select elements.

If you’re looking for a good book on jQuery you should check out Visual Quickstart Guide jQuery by Steven Holzner. Its provides a bunch of good examples.

PHP 4 and MySQL 4 End of Life Announcement

For those of you who haven’t taken the time to explore Windows Presentation Format, you should definitely put this at the top of your “to do” list. It will be time well spent. WPF is fast becoming widely held as an industry standard and I would venture to say that it will be used in the near future to build other development tools upon.

Windows Presentation Foundation (or WPF) is a graphical subsystem for rendering user interfaces in Windows-based applications. WPF, previously known as “Avalon”, was initially released as part of .NET Framework 3.0. Since that time it has become widely held as a programming standard. Microsoft Silverlight utilizes WPF to provide embedded web controls similar to Adobe Flash.

Whether you’re looking at it from a beginner’s point of view or just needing a reference, I highly recommend reviewing these free videos created by Microsoft. They are well worth the time and are presented in such a way that they can be viewed independently as references or as a step by step learning tool. These videos also have accompanying forums where viewers may ask questions regarding the video content.

Here is the Microsoft description of the videos from the site…

The Microsoft Windows Presentation Foundation (WPF) provides the foundation for building applications and high fidelity experiences in Windows Vista, blending together application UI, documents, and media content, while exploiting the full power of your computer. These video training sessions provide some great launch points to creating your own WPF applications.

Microsoft WPF Videos