One of the hot discussion topics atm is around the question: who pays a speaker’s costs? And who should pay?

I think there’s a couple of different ways to look at this: from an economic point of view, and then separately from a moral point of view.

The Economic Arguments

Writing and presenting a talk – whether it’s at a user group or a conference – takes both a significant amount of time, and a significant amount of cash.

A new tech talk can take anywhere between 20-40 hours to write, rehearse and polish. That’s 1/2 to a full working week. It takes significantly longer if the talk needs to be accompanied with example code or even a usable code library.

Unless the event is local, you can add in up to two days of travel time on top, plus the time spent at the event itself. And you can add in more days on top to cover both international travel and dealing with jetlag.

It’s impossible to travel without spending money. Whether it’s fuel for the car and car parking charges, or train tickets, or flights, none of that happens without money. And let’s not forget accommodation!

Someone, somewhere, is paying for that time. And someone, somewhere, has to hand over the cash to pay for the travel.

So every speaker – and every employer who lets staff do speaking gigs on company time – has to treat any speaking opportunity as an economic transaction. You may not have ever thought of it in those terms before, but that’s what is happening.

It’s down to individual speakers (and/or their employer) to decide whether or not doing a talk is “worth it” to them. We’ve all got our own motives, and there’s no such thing as a one-size-fits-all approach to it.

I run my own company, and I have over three years now of financial data on whether or not it is worth it or not for me. If you’re curious, the series of talks I’ve been doing to date has cost my firm over £13K in cash paid out, and over £5K in time spent on talks instead of on billable work. So let’s call that about £20K. That’s just for giving talks here in the UK. There’s no international travel at all in that. And it doesn’t account for the many many evenings and weekends I’ve given up of my free time too.

These are just my costs. For several reasons, I am an outlier:

  1. I write a brand new talk for every speaking opportunity, which is very unusual.
  2. I have non-coeliac gluten-intolerance (NCGI). It’s an incurable auto-immune disease. Eating out is very difficult, so I often end up renting an apartment so that I have a kitchen to cook in. That does cost a lot more per-night than a hotel room does.
  3. I’m not tied to an office desk, and can work from pretty much anywhere. I can do billable work on trains and from rented apartments, to reduce the amount of billable hours lost. Many people aren’t that fortunate.
  4. Those costs include the A/V equipment I use to video my talks.

There’s another side to the economic argument, to do with the event itself, and it’s where the moral arguments overlap.

The Moral Point Of View

Generally speaking, events fall into these groups:

  • Community meetups, such as monthly user group nights. Tickets are free (as a rule). Sponsors cover venue costs, free food, and any swag handed out.
  • Community conferences. The tickets aren’t free, but (normally) the tickets are subsidised by the conference’s sponsors. The organisers may (or may not) generate a surplus.
  • Commercial conferences. They’re run to make a profit for the organisers, and it may even be their sole or primary business.
  • Marketing events. They exist to promote the company in one form or another (normally as the third leg in tripod economics), or to provide a platform for attending companies to promote themselves. The economics for these range greatly. Some are run for profit, some are not. Many of them are put on by professional event organisers.

There’s overlap between these groups, and sometimes an event can appear to be one kind (e.g. a community conference) to the attendees when, behind the scenes, it’s actually a commercial conference or a marketing event of some kind.

I think there’s a couple of moral issues here, spread across the different event groups.

The first problem is accessibility. How do we create speaking opportunities for new speakers? Generally speaking, they’re the least likely to have the economic means to pay their own way.

For me, this is important. We need new voices all the time. We need new experiences to be shared, and new perspectives to be shared. It isn’t healthy for the same people to be trotting out the same stuff year after year. It isn’t healthy for our professions, and it isn’t healthy for our communities.

Yes, user groups offer a way to get started. But how do new speakers get from there to other opportunities? Some of them become developer advocates, and (amongst other duties) it becomes their job to speak at events on behalf of their employer. Others find a way to swallow the costs themselves. Most simply drop out, unable to find a way forward.

Then the other problem is around unpaid services. If I’m speaking at your for-profit event, I am (in effect, and often in law too) a supplier. I am supplying a service (a presentation) to your business. Your business is using that service (along with the services of your other suppliers) to make money.

And when your business insists that it cannot afford to pay the suppliers, and trots out an endless stream of creative excuses why, this is in effect a zero-sum game. For them, it’s not about the economics. It’s all about the for-profit event holders believing that they can only have a successful event if they get services supplied for free.

When you come across these people, you’ve got to take a long, hard look at the economic transaction. Are there clear benefits, and are they worth the cost? And is it worth setting aside the moral objections?

Fortunately, as with most things in the software industry, we can look to other (arguably more mature!) walks of life, where this kind of thing has already happened, and learn from them. The music industry is full of stories about pay-to-play gigs, for example.

And there’s always the gold standard. Would a plumber do it, either at all, or on those terms?

Be the first to leave a comment »

Another Fantastic PHPNW Conference!

Posted by Stuart Herbert on October 8th, 2015 in #phpnw.

I’m back from this year’s PHP North West Conference, and finally have a few moments to talk about what was (yet again!) another excellent year.

I was there to present two talks – Introducing a Quality Model For MVC Applications, and Ways To Measure Your ORM’s Cost. It’s the first time since the php|cruise back in 2004 that I’ve presented twice at the same conference, and brings me up to something like 15 unique talks and workshops presented over the last 11 years.

Are you a good scout? – PHPNW15 Track 3 from phpboyscout

I want to highlight one talk in particular from this year’s conference – Matt Cockayne talking about being a good code scout. This talk got promoted from the Unconference track to a spare slot on the Sunday morning. I’ve been thinking about pitching a keynote about how we all need to be great ambassadors for PHP, and I think Matt’s message would make a great keynote for our community.

Whether I’m speaking or just attending, I always enjoy the PHP North West Conference. Their conference team always do everything that they can to make each conference the best that it can be. In my opinion, the explosion of quality, community-based PHP conferences in Europe owes much to the example set particularly by PHP North West. We’ve come a long way from when I started speaking back in 2004 🙂

I’m really grateful that conference committees here in the UK – both PHP North West and PHP UK – continue to give me opportunities to come and talk at their conferences. Whether it’s about the problems of framework lock-in, component-based architectures, Git workflows, or indeed about driving quality, I’m often talking about things years before the PHP community moves that way. My work is often about solving problems most people don’t yet realise that they have, and that can’t be an easy sell, both within the committees that select talks for conferences nor to attendees when they’re buying their tickets.

This year’s conference may be over, but there’s no rest to be had.

  • I’m already preparing another talk to deliver to the PHP Oxford user group later this month, called “Why Do We Test?” – expect plenty of ethical dilemmas in this one
  • November sees me once again volunteering at Aberystwyth University, coaching 2nd year Comp Sci (and related) students on job hunting
  • I’ll be speaking at PHP Surrey at the start of January 2016, possibly on writing a test suite for PHPFastCGI – you should come just to watch Andrew give his PHPFastCGI talk, it’s cry-out-loud funny

… and I’ve promised both Glasgow PHP and The Edinburgh PHP User Group that I’ll come up and present to them before the end of 2016.

Be the first to leave a comment »

Here is the original blurb for this talk …

Your project has adopted an ORM such as Doctrine because it’s the quickest way to hook your code up to your database. Things are looking up, and your website is about to take off. Aaaand then the first complaints start to come in that your site isn’t coping with the new customers. You can’t find a problem in your own code. Could it be the ORM that’s the problem? How can you tell?

In this talk, Stuart will show you how you can use off-the-shelf open-source tools to work out what your ORM is doing, and whether or not it is the cause of your performance problems. He’ll show you how to measure the database itself and the ORM code, as well as providing useful strategies to reduce the cost of your ORM without having to abandon the ORM altogether. Finally, he’ll show you how you can extend these techniques to other parts of your application, so that you’re never in the dark again.

Be the first to leave a comment »

Here’s the original blurb for this talk …

Your integration, functional and non-functional testing gives you a good idea if your code will work on Production. But how do you go about measuring the quality of code that already seems to work? How do you make that measurement repeatable? How do you share it with clients in government, finance or other large enterprises who are looking for a 3-5 year shelf-life from your code?

In this talk, Stuart will introduce you to SQuaRE, the international standard collection for software quality. He’ll give you a tour of all of the available and upcoming standards in this area, before taking a deep dive into the Product Quality Model from ISO/IEC 25010:2011. He’ll explain what a quality measurement is, how you link them to your project’s quality criteria, and how you incorporate them into code reviews, QA teams and management decisions.

You’ll leave this talk ready to start measuring and improving the quality of your product or service, with the tools you need to not only maintain quality but also to keep increasing it over time, even when faced with staff turnover.

Be the first to leave a comment »

PHP is the world’s #1 programming language for creating websites. But it’s capable of so much more. How about real-time processing the social firehose? 🙂

More Than Websites: PHP And The Firehose @DataSift (2013) from Stuart Herbert

Thanks to Brighton PHP for hosting this talk last month.

Be the first to leave a comment »

I’ve mixed feelings about the PSR standards to date.

  • PSR-0 has standardised autoloading in a practical way. Sure, it does have an evil design flaw (different classes can map to the same file on disk), but in practice it’s not a problem that happens.
  • I’d have personally liked to have seen PSR-1 go further, and address method naming in more detail (in particular, that method names should start with a verb), and also address getters/setters and protected vs private.
  • I’ve no personal interest in PSR-2, and am philosophically against “layout” coding standards like this.

… so I wasn’t sure what to expect when I decided to add PSR-3 support to a private framework I use to build test tools at DataSift.

What Is PSR-3?

PSR-3 is a proposed standard (voting has finished, it should appear as an accepted standard when the PSR folks recover from too much Christmas turkey) describing a common logging interface for PHP frameworks.

It’s based on a small subsection of RFC 5424, which describes the Syslog standard, which is a very sensible choice. Sysadmins think in terms of Syslog levels, and they utterly hate dealing with loggers that don’t map cleanly onto Syslog.

What Does The Interface Look Like?

To support PSR-3, you’re required to implement the following methods:

  • emergency($message, $context = array())
  • alert($message, $context = array())
  • critical($message, $context = array())
  • error($message, $context = array())
  • warning($message, $context = array())
  • notice($message, $context = array())
  • info($message, $context = array())
  • debug($message, $context = array())
  • log($logLevel, $message, $context = array())

You can see the proposed interface in full here, including the constants for $logLevel.

The $context is a list of named parameters to substitute into the $message. The special parameter ‘exception’ is reserved for an exception that needs to be added to the logs.

A Critique of PSR-3

PSR-3 is built on a good idea, but there’s three areas where I think PSR-3 could have been better:

  • the method names in the LoggerInterface
  • the handling of the exception parameter
  • the LogLevel constants

I’d have also liked to have seen trace level logging supported, although I can understand why most PHP developers won’t be aware of that practice.

Better Method Names

It’s perhaps a small thing, but I’m a big fan of making code more readable by having all method names start with a verb. I find that it makes code more self-descriptive, and that it’s much easier for casual contributors to grok.

So, instead of this:

  • $logger->emergency(“Captain, she canna take no more”);

we could instead have had:

  • $logger->logEmergency(“Captain, she canna take no more”);

Like I say, a small thing, but in my experience it’s improving all of the small things that leads to big successes, especially in larger code bases.

Handling The Exception Parameter Properly

To paraphrase, the PSR-3 standard says this about the $context parameter: “here’s a list of key/value parameters, but one is special”. That “but” is a code smell!

Not being able to treat all of the key/value parameters equally (slightly) increases the complexity of handling $context, increases the performance cost of logging, and forces the Logger implementation to do things that PHP could handle for us.

A better solution would be to move the exception out of the $context and make it a separate parameter like this:

  • logEmergency($message, $context = array(), Exception $cause = null)

This would allow PHP to make sure that only a genuine Exception was passed into the log method, and would allow the implementation to treat all of the key/value pairs in $context equally. This is a cleaner interface to implement.

Log-Level Constants

RFC 5424 defines the log levels as an ordered set of integers. This is deliberate, as it makes it trivial to say “only log warnings and above”. Unfortunately, because it was difficult to crowbar this into Monolog, the decision was taken to go with strings for the log-level constants. This regrettably increases the complexity of all other loggers.

If you look at pull-request to add PSR-3 to Monolog, you’ll notice that Monolog is explicitly relying on the value of the PSR-3 constants to map them directly onto Monolog class constants:

375	+    public function log($level, $message, array $context = array())
376	+    {
377	+        if (is_string($level) && defined(__CLASS__.'::'.strtoupper($level))) {
378	+            $level = constant(__CLASS__.'::'.strtoupper($level));
379	+        }
380	+
381	+        return $this->addRecord($level, $message, $context);
382	+    }

This is done because (ironically) Monolog already uses numerical log levels internally, with the debug level having a value of 100, and the emergency level having the value of 600. There was obviously the risk of Monolog log level constants being passed in instead of the PSR-3 constants, where it would have been impossible to tell them apart if they were both numeric. I’m sure other existing loggers probably face similar issues.

It’s a tricky issue, but on balance I think the wrong decision was made here for the wrong reason, and the community would have been better served longer-term if PSR-3 had supported the RFC 5424 values for the log level constants.

Final Thoughts

PSR-3 isn’t objectionable … it’s just that it could have been a bit better than it is.

I’ve added both PSR-3 support and the revised methods from this blog post to my internal LogLib. PSR-3 will allow me to inject LogLib into third-party components that support it. My own code will be using the revised methods I’ve proposed here, for the reasons mentioned above.

Comments Off on Personal Thoughts On The PSR-3 Log Proposal

Last weekend saw the PHP NorthWest user group run their fifth conference. Spread over three days, it gave over 400 folks who attended great talks on a wide variety of topics from speakers both established and new. Once again, Jeremy, Rick et al ran an excellent conference, and I’m already looking forward to next year’s event.

0I0B1694.JPG

See more of my photos from the PHPNW12 conference on Flickr.

Be the first to leave a comment »

I haven’t really talked much about my upcoming tutorial session at #phpnw12 next month before now, but I hope there’s still time to convince you to come along and learn how to use Git as your team grows in size.

That’s what I’m teaching: a strategy, plus supporting tools for Git called HubFlow, that will help you stay sane – and more importantly help you keep delivering – as your team starts to collaborate on your product.

It isn’t my strategy: the credit must go to Vincent Driessen, who first blogged about GitFlow at the start of 2010. And they aren’t my tools: again, they originally come from Vincent. All I’ve done is adapt them for working against GitHub – hence the name “HubFlow”; but if BitBucket is more to your taste (or wallet) then rest assured that both tools and strategy work can be adapted for there too.

Maybe you don’t need this strategy. If you’re working on one-off consulting gigs for clients, where you can get in quick and get out quick, then HubFlow might not be necessary. But if you’re working on any sort of product or service, either commercially or open-source, then I can strongly recommend HubFlow to you – even if you’re just at the one-man startup stage. And the benefits of adopting HubFlow only increase as your team grows in size.

I’ve already put a lot of effort into documenting HubFlow, and if you’ve previously read the docs, you might be feeling confident enough to adopt it by yourself. If you do, I think that’s awesome, and you should go for it without delay. Please do email me if I can help in any way. I’m passionate about everyone adopting the fundamentals of software engineering, and few things are more fundamental than good source control.

But if you’re still reading at this point, I hope that I can convince you to buy one of the remaining tickets for my tutorial session at #phpnw12. I don’t personally profit by it – all of us teaching at #phpnw12 are volunteers – but maybe you will.

What I’m teaching is the approach that I’ve introduced to DataSift. You might not have heard of us yet; we provide a platform for filtering social data in real time, handling terabytes of data a day at full firehose-scale, and many thousands of incoming data every second. And every piece of that data goes through code written in PHP.

Although we’re a young startup, we’ve already grown beyond 20 developers, and with that many people collaborating to build that platform, with every team working at their own pace, we needed to adopt a common way of working together with Git and GitHub so that the company continued to scale well.

  • It had to be a way that allowed every developer to take full advantage of Git, especially when it comes to committing their work early and often.
  • It had to allow developers to form ad-hoc teams that worked at their own pace.
  • Remote working is a fact of life these days, and it had to work just as well whether everyone is in the office or working from somewhere else.
  • It also had to ensure that only work that had been finished made its way into any of our releases.
  • We wanted to make sure that there was an opportunity to review every change before it went into a release. Code reviews play an important part in delivering high-quality work time after time after time.
  • We didn’t want pending releases to hold up new development, ever.
  • And if something did screw up in production, we needed a way to go back to our last known good version, fix it, and release *that* – all without disrupting any pending releases or existing ad-hoc teams.
  • Finally, it had to be easy to teach to people who are new to Git and GitHub, preferably by wrapping complicated Git operations up inside a single command each time.

Those are the benefits that HubFlow gives us. And at #phpnw12, I’ll be teaching everyone who attends my tutorial session how to get those benefits too.

What makes me qualified to teach this topic? And what makes me qualified to be teaching at all?

I’ve got 18 years of experience setting up and/or running software configuration management, taking in systems as diverse as RCS, CVS, Perforce, Continuus, Clearcase, Subversion, Mercurial, and Git. I’ve done this with, and for, organisations as small as a one-man team all the way through to large international corporates. I’ve even built a version control system for one company in the past. (Git is much better! 🙂 And I was around long enough to see (and learn from) the failures as well as the successes. (I’m a big believer that success teaches you a bit, but failure teaches you more). Plus, I’m the author of the HubFlow strategy, and the maintainer of the HubFlow extension for Git.

It simply isn’t possible for me to distill all of that rich and lengthy experience down into the documentation that I’ve written for HubFlow. I think the documentation is good – I wouldn’t have put my name to it otherwise – but I think you can learn even more from me in person.

I’m a qualified teacher of adults. I’m trained how to teach, and I’ve had a lot of practice doing so. My first PHP conference appearance was back in 2004 on Marco’s php|cruise, and since then I’ve spoken at the PHP NorthWest and PHP UK conferences several times. I co-wrote the Zend Certification Study Guide for PHP4. Once a year, I teach at the University of Aberystwyth, helping their Comp Sci students prepare for applying for jobs for their year in industry. Plus I’ve done a substantial amount of teaching and mentoring as part of my job and open-source work over many years. And away from computers, I’ve been teaching martial arts for over 12 years.

If you need the benefits that HubFlow brings, then I’d love to teach you in person. You can buy a ticket for my tutorial day on the #phpnw12 website. I hope to see you there.

Be the first to leave a comment »

I don’t need the ticket that I bought for the PHP NorthWest 2012 conference, as I’m doing one of the tutorial sessions on the Friday. So I’m going to be giving my ticket away to one lucky reader. The ticket is for both the Saturday and the Sunday sessions, and if memory serves covers all the socials too. You’ll have to pay for your own transport and hotels tho, so please don’t enter unless you’re definitely able to travel to the conference if you win.

To win my ticket, leave an interesting PHP or software development-related question in the comments below. The winner will be the question that I think would be the most interesting to answer, and I’ll answer it for you over either lunch or dinner at the PHPNW12 conference. You must leave your comment by 9am BST on Monday 10th September, and I’ll announce the winner on my blog later that day.

So get asking away 🙂

(Please note: comments on my blog are moderated, so if you leave a comment and it doesn’t show up straight away, that’s why).

UPDATE: we have a winner, who I’m currently trying to get in touch with

1 comment »

The PHP North West User Group ran it’s 4th (and largest yet!) PHP conference – PHPNW11 in Manchester last weekend.

My last set of photos from PHP North West 2011 are the odd ones out, the ones that didn’t really fit into any of the other sets.

I hope you’ve enjoyed my photos from the conference, and maybe – just maybe – they’ve made you think about going to a PHP conference somewhere near you in the near future.

Rob Allen

Derick Rethans

Jeremy Coates

So You Want To Be A Rockstar?

On The Way To The PHPNW11 Conference

Picadilly Gardens, Manchester

The Mothership Hovers

Opening The Call For Papers For PHPUK12

Cups of Tea

All Hail Our New Wifi Overlords!

Rick, Kerry, and Jenny Admire The Many Poses Of Jeremy Coates

Jeremy Coates - Magma Digital - PHPNW11 Organiser And Platinum Sponsor

Be the first to leave a comment »
Page 1 of 3123

This Month

December 2018
M T W T F S S
« Sep    
 12
3456789
10111213141516
17181920212223
24252627282930
31