Tag Archive for Software Development

Setting up a Windows Development Server

Recently we acquired a new client and set up a new Windows development environment for their project from scratch. Here is a profile of the process we used.

We started working with a small business based in Vancouver, Washington, USA. This was a new client for us, and they desperately needed help with their business processes. (They also requested help with their website, but that is a separate topic for a different day!)

The client was using a mish-mash of common small office/home office software products, including Adobe Professional and Microsoft Office and the processes that were being used in their business were quite convoluted. For example, the order taking process, which was needed for each new order they took, had many repetitive steps across several different programs, involving cutting and pasting and lots of duplication of effort.

For our first step, we had a consultative meeting with the client. This meeting immediately produced a tons of value in the form of actionable insights. These insights showed exactly where we should help them optimize their business processes. This optimization, when complete, will save them lots of time in the order taking process and in following up on orders. This will enable them to spend less time processing the orders. This saves costs on the staff time it takes for each order, reducing the per-order overhead, as well as allowing the order taking process to scale better. This enables them to take more orders and do more business. This a great thing for growing the business!

During the initial meeting we took detailed notes and we identified the key elements in each process. We also began to outline the solutions we would implement at each step.

This is the same basic process development that we have been doing professionally for over a decade.

Since they had a Microsoft Access database in a core role in their internal processes, we outlined a path to step from Access to SQL and then to a web-based app which we would custom develop for them. This is the same basic process development that we have been doing professionally for over a decade. This client’s use case fit nicely with the profile for this kind of work.

In order to facilitate this development process, we immediately provisioned an Amazon EC2 instance with the latest and greatest Microsoft Windows Server. Going this route is much quicker to implement than provisioning local hardware and software, and it is also less expensive, more flexible, and offers better performance out of the box. The required software licenses alone for this development environment and the related production environment would easily be several thousand dollars. Amazon has low recurring fees for their Web Services that are based on usage. Those fees automatically account for the necessary licenses for the software we use.

Since we do so much development work locally, on either Macs or Linux-based machines, I was curious to see what tools we would set up on this Windows based server for our team to share. As I was the one setting this up, I brought along many of my favorites tools. Some of them seem outdated, but they still get the job done. First I installed the truly cross-platform (consistently developed for multi-platform) tools that remain the same across the various dev platforms.

In this case these were:

As far as Windows specific tools for this dev server, they included:

We connected SourceTree to our BitBucket account. With the distributed source tracking, all of the developers on our team are able to program, test, and debug on their local machines and then push and pull accepted changes to and from the central repository.

It’s been a little while since I set up a Windows Server as a Dev environment, and I guess I was a little surprised to see myself using the same old tools. However, it gets the job done, and that’s great!

 

Custom Repositories for GitHub Forked Composer packages

So today we had to make a custom repository so that our composer installs could look for custom changes to a particular package that was causing a problem with one of our client’s production applications.

The only current change in this particular package was a solitary “if” statement added to a single line of code. This statement checks to make sure that the object operated on is indeed an object: in certain situations in the production app it throws a fatal exception claiming a “non-object.”

First we had to ask two (rhetorical) questions:

(1) Where do PHP Composer packages come from?

and

(2) How do you get composer to install a non-composer package?

The first step was to fork the package on GitHub:

The original package is Piotr Śliwa’s excellent:

https://github.com/psliwa/PHPPdf

And the fork lives here:

https://github.com/yourcomputergenius/PHPPdf

We looked at simply adding the forked package to Packagist, but although we intend on maintaining this as a “real long-term fork”, that is only if this change or an equivalent fix are not added to the primary package in the near to medium term. Since that seems like an edge case, we were happy to go the VCS route. Satis and Toran Proxy just looked like overkill for this simple implementation.

Once the forking was complete, we cloned the forked package into GitHub for Mac (nice!).

We branched into “missing-object-protection” (the name of the branch will be important later).

We edited the file “lib/PHPPdf/Core/ComplexAttribute/ComplexAttribute.php”, committed the change, and pushed.

Then on to editing composer.json.

We tried to run “composer require” and “composer update” on a development version of the application, after “composer remove” took care of the original psliwa/PHPPdf package. However, we ran into the issue that our newly created PHPPdf branch no longer satisfied the requirements for the PDF Bundle dependencies that was also used by the production app!

Back to GitHub we went, and we forked:

https://github.com/psliwa/PdfBundle

to:

https://github.com/yourcomputergenius/PdfBundle/

Then we cloned that into the desktop and made a solitary commit to the new fork’s master branch: a single commit updating the requirements in that project’s composer.json.

Then we updated our repositories in our development machine’s composer.json, just after the “require-dev” entry, so it contained entries for both newly forked packages:

    "repositories": {
        "yourcomputergenius/php-pdf": {
            "type": "vcs",
            "url":  "https://github.com/yourcomputergenius/PHPPdf/"
        },
        "yourcomputergenius/php-bundle": {
            "type": "vcs",
            "url": "https://github.com/yourcomputergenius/PdfBundle/"
        }
    },


We were able to leave the names the same in the “require” section of the composer.json file — one of the beautiful (and maddening) things about composer is the presence of these sorts of conventions. Composer is smart enough to figure out which packages are being replaced by custom repos.

However, we did update the “require” section of composer.json to look for the “dev-missing-object-protection” branch, as below:

        "psliwa/php-pdf": "dev-missing-object-protection"


The long and short of the day is that the application runs “composer update” and successfully grabs those two packages from the forked repos. Hooray!

Remember Labels in Gmail?

I just counted (html > spreadsheet > row count / 2) the number of labels I have in my primary* Gmail account: it came to over 80.

How many do I use on a regular (daily) basis? 0.

How many do I use on a weekly basis? Maybe a handful. 5-10.

I do special purpose creates for them, but more realistically it’s easier to throw an IMAP setup on Thunderbird and use ImportExport Tools to do any significant manipulation of email data.

So, yup, it’s pretty much time for them to go… even though they were the hit controversial thing, with Gmail pulling us away from “real” IMAP folders at the time.

Cheers!

 

*Gmail: You can’t have just one. At least no self-respecting geek can, anyway.

Thank you! Rolling on GIT

FINALLY we’re rolling on GIT…

The link that pushed us over the edge:

Thank you: http://www.manniwood.com/starting_a_project_with_git.html