If you know me, you know that I am passionate about managing software development teams and the projects they work on. So I was very interested when Addison Wesley wrote me and asked me if I wanted to review their latest offering “Reflections on Management: How to Manage Your Software Projects, Your Teams, Your Boss, and Yourself” by Watts S. Humphrey. (I was even more excited when they sent me the ePub version as I’m trying to justify my purchase of an iPad.)

The book is only 288 pages long (539 if you set the point size to a readable size on the iPad) but honestly it is jammed packed with things that managers of software development teams and projects need to know. I really am at a loss for where to start reviewing it because I feel the need to simply reiterate all the points that Mr. Humphrey made in the book.

Who it is for

This but is a must read for anyone managing a medium to large size software development team. Actually, I would say that it is a must read for any C-Level or VP level at a company who either develops software as their primary function or their business is built around software that is built in house. It is that good.

Who it is not for

If you are managing a small shop or working with small teams, this book won’t give you much in the way of practical advice. It gives you some great big picture advice but nothing that you can readily apply on a day-to-day basis.

What is in it

First off, here is my favorite quote from the book.

When projects go badly, our reaction is often to work harder—by which
we mean work longer hours. But it’s rarely that simple. Projects often
go wrong at the very start, and their problems are generally symptoms
of a deeply dysfunctional organization.

Looking back at the projects I’ve been on, managed, or discussed with clients, I can attest to this gem of wisdom. That quote is from Bill Thomas and comes from the preface of the book. Even so, it indicative of the wisdom that is sprinkled liberally throughout the book.

Mr. Humphrey goes on to touch on just about every one of my hot buttons in the rest of the eight chapters. His advice runs the gamut from “how to manage a project”, to “how to manage a team”, to “how to manage your boss”. All of it drawing from his 60 years of experience in IT.

Unlike most modern management books that tend to be pithy with pull-quotes, and written in a style reminiscent of motivational speakers, “Reflections on Management” is written in a much more formal style. (I’d say like you would expect form an old white guy but I am told these days that I am an old white guy.) It’s not stuffy at all but it can be a bit dry at times. What keeps your attention though are his liberal sprinkling of real-life examples of the points he is making.

Conclusion

The ideas and principals espoused by Mr. Humphrey are solid. Even if you disagree with this methodologies, it is difficult for anyone to disagree with the principals. Personally, I think it that a copy of this book should be presented to every management candidate at least 3 weeks before their promotion. Reading this book will help them either determine that they don’t want to be in management or get started on the right foot. Either way, the company and the candidate wins.

Kristina Chodorow talks about scaling MongoDB.

This is part of the spring TEK·X webcast series and is sponsored by Microsoft and hosted by php|architect.

It was just one short year ago that I began a new job working as a “programmer;” prior to that, I’d styled myself a “Web developer” or something similar, but the new job meant that I’d be doing something much different than before. During the interview, terms like “object-oriented programming” and “SQL” were tossed about, and I truthfully acknowledged that I understood and used such things in my working life, although not terribly frequently. (My previous job was a Filemaker and procedural programming shop.)

When I arrived and began programming Web applications, I took a look at CakePHP, and suggested we use it. Soon, it was implemented for basically all new development projects. I quickly realized, though, that I had a huge knowledge gap. Sure, I know what object-oriented programming is, and even done a bit of stuff previously, but when my boss suggested we might use things like an observer pattern on some legacy code, or when he talked of extending CakePHP’s controllers in various ways, I knew I’d need to expand my skills.

And even with the database side of things, where I felt a bit more comfortable, I found that my knowledge of SQL was a bit rusty in spots—such that I couldn’t decide if what CakePHP was doing (say, with joins) was correct or whether I’d need to do things differently.

Frameworks like CakePHP, Zend Framework, and Symfony allow you to quickly and easily write a “real” application, but in doing so they tend to shield you from things like raw SQL and obviate the need to manually load or extend classes, for example. I contend that this is a good thing, but only if you understand the “guts” of the system—that is, OO and SQL, for example.

Why? Consider what happens if your framework loads data into a variable in a completely unexpected way. If you don’t understand the SQL that’s going on under the hood, what chance do you have of determining whether the framework is wrong—or perhaps you’re not calling the data in the right way?

In a similar vein, knowing how to program in an object-oriented way is also vital. I’ve looked at the Lithium framework recently, and confess to not understanding a lot of what’s going on. Sure, there’s some documentation, but I’m certain my learning process would be helped if I understood things like singletons, or lazy loading, or even anonymous functions.

This goes beyond mere debugging or learning new technologies. As in the example I gave earlier, it’s quite possible that you’re going to hit a point at which you want to do something the framework doesn’t do natively; in this case, your OO skills come into play, letting you get the job done. Or what if the framework can’t handle the poorly designed legacy database you inherited? Suddenly your SQL-fu doesn’t look so useless, since you’ll be able to write occasional custom queries when the framework falls flat.

But even beyond that, there will be times during which you can’t (or don’t want to) use a framework. I recently took a look at CouchDB and PHPillow, and I confess that I still can’t get PHPillow to work. My OO chops are simply not up to par. That experience taught me that I really need to start taking my favorite PHP book to bed with me a little more frequently.

So, even if you use a framework, take the time to get to know object-oriented programming and SQL (useful even if you’re using a document-oriented database, I think). They truly form the building blocks of programming.

Image of building blocks from Flickr user Artful Magpie. Published under a Creative Commons Attribution-Noncommercial-No Derivative Works 2.0 Generic license. http://www.flickr.com/photos/kmtucker/3355551036/

I hate wizards. No, not the Harry Potter kind (although, I will confess I don’t like that kind very much either), but I hate wizards that pretend to help programmers do things. More often than not, they end up either getting in the way or hiding some magic that I need to know about. This isn’t really a problem when working with PHP, since most of the code I write in PHP is back end code and doesn’t require a UI per se. That being the case, wizards aren’t a normal part of my life. (For the record, the closest I come to using a wizard regularly is Zend_Tool but even then, I know enough about the magic going on to write my own providers, so it’s not a wizard as much as it’s just a convenience.

However, of late I have been working with Flex Builder 3 and now Flash Builder 4 (FB4). While wizards for programming might not be the norm for PHP developers, Flash and Flex developers apparently do like them. To be honest, after working with FB4 now for a few weeks, I am starting to see that wizards aren’t all bad—in fact, some of them are even kind of cool. In this two-part post, I want to talk about connecting Flex applications to server-side PHP APIs using the Data Services wizard that ships as part of FB4.

The Old Way

First, let me say that, as nice as the new Data Services are, I worked with Flex Builder 3 and really liked the old way of connecting to data services. The HTTPService object was super flexible and very simple to use—in fact, when I first started working on the code for this series, it was my intention to prove that the new way was inferior to the old way. It’s funny how technology can surprise you sometimes.

In Flex Builder 3, the way you connected to an API (XML or JSON usually) was to use something like this:

<s:HTTPService id="twitter"
               showBusyCursor="true"
               fault="showFault(event)"
               result="doSomething(event);"
               url="http://example.com/myapi" />

See, that is easy. There is no behind the scenes magic: like PHP, I can get what I need done, done and move on to the next task. I’ve built several AIR and AIR2 applications using HTTPService as my multi-tool for connecting to the outside world because it is just so easy to work with; I like simple tools and HTPService was as about as simple as it got. This is why I was nonplussed when Adobe added “Data Services” to Flash Builder 4.

The New Way

When you first create an FB4 Application, you will immediately notice a difference from Flex Builder 3, the “Declarations” section of the code

<fx:Declarations>
<!-- Place non-visual elements (e.g., services, value objects) here -->
</fx:Declarations>

FB4 now divides your declarations from your visual elements. That is the first thing you have to get used to. It is still easy to hand code an HTTPSerivce—you just have to put it in the new <fx:Declarations> section.

This is still my favorite method for connecting to third party web services like Twitter’s API (the Hello World of Web 2.0). Fetching data like this is dead simple, but, if you want to get into more complex operations like updates and deletions, you inevitably end up writing code by hand. Depending on the API you are talking to, this can quickly become tedious and, if you are a good OO programmer, it will most likely mean encapsulating all of this in its own class. If that sounds familiar, the new Data Services option is going to save you a lot of time and hand coding.

Figure 1: Connecting to Data Services

The “Connect to Data Service” button is on the upper right of the Data Services tab. Clicking that button will open the wizard and help you get connected.

Figure 2: Selecting Service Type

The first thing you have to do is select the type of service you are connecting to. PHP is one of your options. Selecting PHP will require you to point the wizard to the actual class you will be talking to so that it can use PHP’s reflection to gather information about the class. This means that if the API is hosed on a server you don’t have access to; you will need to use HTTP instead. While this will negate some of the benefits of the wizard, it will still set things up for you and you can manually configure your Data Service.

Figure 3: Configuring PHP Service

NOTE: For some reason, the class has to be inside your web root. Since this is considered a bad practice, you probably wouldn’t normally have the class available where Flash Builder 4 is looking.  I feel confident that the answer to this conundrum is a simple configuration setting but I’ve yet to find it. For the purposes of the demo, I put everything inside of web root. I will post a follow-up post once I have a solution for this problem.

Once you have entered a class location, it will attempt to use PHP’s Reflection to pull out methods, parameters and return types. To do this, Flash Builder 4 needs Zend Framework. If you have not already configured it, you will get the following dialog box:

Figure 4: Install Zend Framework

If you already have Zend Framework installed on your system you can save yourself ~20MB by pressing cancel, backing out, finding amf_config.ini and setting the zend_path setting.

For the purposes of demonstration, let’s have it generate a sample class for us. (See Figure 3), Again, everything needs to be inside the web root for things to work properly.

NOTE: This feature is for prototyping only! The program warns you, and for good reason, that you do not want to use this code in production, ever, for any reason, period.

Figure 5: Generate a sample PHP class

Flash Builder will generate the PHP class plus all the necessary ActionScript code to manipulate a table in your database. The resulting class will have your database credentials hard coded in it and will be in your web root. You can see why it’s not a good idea to use this code in production now.

That having been said, I gave it the wp_user table from a test install of WPMU I have on my local machine and it did a good job. The PHP code is quite good. It is primarily procedural code wrapped in an object wrapper but it for prototype code, it’s good.

Since FB4 uses PHPDoc blocks as part of its introspection process, it generates the appropriate docblocks for each of the methods. In my case, it generated 6 methods necessary to add/edit/delete and list the users of my test blog. More importantly though, the wizard created 2 ActionScript classes necessary to talk to the API, _Super_WpusersService.as and WpusersService.as, both in the Services directory. The first one, _Super_WpusersService.as is where the code necessary to talk to the API is hosted. The header comment makes note that this is generated code and should not be edited. It can however, be regenerated at will. The second file, WpusersService.as, is where any customizations go. It is this class, a subclass of the first class and  is the class that is actually instantiated. You can override any of the methods and add your own functionality here. This is a verbose but overall well-thought-out solution to having generated code will still allowing for modifications.

Conclusion

As you can see, connecting to PHP code from Flex is actually much easier in Flash Builder 4 and now you actually have more options with the ActonScript  classes being automatically built for you. The old way of doing things still works and there are legitimate cases where it is the best answer. However the new Data Services wizard does have some nice benefits.