Qafoo GmbH - passion for software quality
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

:Author: 		www-data
:Date:			Wed, 31 Oct 2018 10:07:55 +0100
:Copyright:		All rights reserved

=======================
PHP Hypertext Processor
=======================



- Qafoo Profiler Closed Beta

  We are excited to welcome you to the first blog-post about the Qafoo
  Profiler, a tool for PHP application performance and profiling.Qafoo
  profiler allows you to collect PHP response times and detailed profiling
  data on your applications. Gain immediate insights on how to improve your
  application's performance. Use our knowledge on open-source PHP libraries,
  content-management-systems and ecommerce platforms to find performance
  bottlenecks.

- Why you need infrastructure and deployment automation

  The amount of time wasted on setup, synchronization and deployment of
  applications is often ignored by teams and managers. Manual server
  management and application deployment are a huge waste of time and
  ultimately money. In addition, manual work is often prone to error and a big
  risk for uninterrupted uptime of production.Software quality does not stop
  with tests and good CodeSniffer and PHP Mess Detector scores. The deployment
  and setup is equally important to the quality of an application. From our
  experience, this is a field where many teams could still achieve huge
  productivity gains.

- Learn OOD - to unlearn it again

  One topic we regularly teach in workshops for our customers is object
  oriented design (ODD), i.e. the art of crafting classes/interfaces in a way
  that the result is an easy-to-understand, maintainable and flexible code
  base.  With the agile focus on shipping working software, some might
  consider the skill of OOD less important. One popular argument is that quick
  reaction to change is more important than designing objects and their
  interaction carefully. I personally look at it the exact other way around.
  This blog post summarizes why you need to learn OOD first, in order to avoid
  it to some degree again.

- Code Reuse By Inheritance

  To me, inheritance has two properties:Defining an is-a relationshipMaking it
  possible to share code between classes by extending from a common base
  classThe is-a relationship between classes is one thing I like to use
  inheritance for. So, to me, a concrete Cache - for example a MemcacheCache
  implementation - extending from an abstract Cache base class is a very sane
  thing to do.  Implementing an interface means, in my opinion, adding an
  additional usage aspect / feature to a class, while the base class defines
  the type of a class. Mind: The base class, most likely, only defines
  abstract methods and does not provide any implementation in this case. I
  discussed this in more detail in a dedicated blog post, which is why I skip
  a detailed explanation now.

- Tracking Changes in PHP Projects

  Since quite some time I've talked to people about the idea for a tool that
  tracks changes in the classes and methods of your PHP project in order to
  detect which entities are changed most frequently, which are often affected
  bugs and other statistics. After some hacking, we are now making it
  available on Github.

- ContainerAware Considered Harmful

  A while ago I tweetedContainerAware is the new Singleton.While many people
  agreed by retweeting and faving. I feel the need to elaborate some more on
  this statement and safe the explaination for the future.

- Fixing Legacy Code

  Working on a green-field project where you can start from scratch and avoid
  all the annoyances you experienced in earlier projects is fun. However, most
  developers cannot enjoy this pleasure but work with legacy code 99% of their
  time. Even harder, many green-field projects turn into legacy within months
  or even weeks.

- Finding the right Test-Mix

  The topic of Test Driven Development (TDD) and unit-testing usually creates
  heated discussions among developers. We at Qafoo are not an exception and
  the topic how to apply TDD in our daily work regularly leads to heated
  discussions.  One reason for this is that both TDD and unit-testing combined
  are by some people seen dogmatically as the only way to do software
  development.

- Testing: Find the Sweet Spot

  How we need to craft architecture and design in order to significantly
  reduce the cost for tests. How to escape from the trap of the inner-platform
  antipattern, where we need to provide all infrastructure and business models
  with an ugly, mocked twin. Simply: How to efficiently write tests? And how
  to avoid that everyone hates them within 10 months, so that they would
  rather deactivate them instead of fixing them.

- Ducks Do Not Type

  I consider public methods not originating from an abstract class or
  interface a code smell – at least when following class based object
  orientation design principles. Let me explain why…