Qafoo GmbH - passion for software quality

Help you and your team benefit from new perspectives on cutting-edge quality engineering techniques and tools through the Qafoo team weblog.

PHP Hypertext Processor

  • Utilize Dynamic Dispatch

    by Tobias Schlitt on Thu, 16 Oct 2014 07:00:50 +0200

    A while ago I replied to the tweet by @ramsey

    Traits are a nice way to provide common functionality to unrelated classes without using static methods on a global Util class.
    with
    Which makes them exactly as evil as static access. Funktionality you dispatch to becomes irreplaceable destroying a fundament of OO: Dynamic dispatch.
    I want to use this blog post to illustrate the concept of dynamic dispatch which I use a lot recently to motivate creating clean OO structures in my trainings. In my experience, this helps people to understand why we want to write code in this way. After that I will show why traits are bad in this direction. Read more on Utilize Dynamic Dispatch

  • Testing Micro Services

    by Tobias Schlitt on Tue, 16 Sep 2014 07:21:39 +0200

    I recently had a short exchange with Ole Michaelis on Twitter about how to end-to-end test micro services. Since I didn't have time to make my whole case, Ole suggested that I blog about this, which I'm happily doing now.The idea behind micro service architecture was discussed by Martin Fowler in a nice to read blog post, so I won't jump on that topic in detail here. Read more on Testing Micro Services

  • Qafoo Profiler Closed Beta

    by Tobias Schlitt on Wed, 25 Jun 2014 16:00:08 +0200

    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. Read more on Qafoo Profiler Closed Beta

  • Learn OOD - to unlearn it again

    by Tobias Schlitt on Tue, 11 Feb 2014 07:09:59 +0100

    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. Read more on Learn OOD - to unlearn it again

  • Code Reuse By Inheritance

    by Kore Nordmann on Mon, 20 Jan 2014 11:19:12 +0100

    To me, inheritance has two properties:

    • Defining an is-a relationship
    • Making it possible to share code between classes by extending from a common base class
    The 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.The other thing you can use inheritance for is to share code between multiple classes. A prime example for this is Active Record, where a concrete record class (for example a BlogPost) extends from a base class which adds the database access logic.I personally think that the latter is one of the worst things you can do in object oriented design. Bear with me for a moment and let me try to explain why I think that. Read more on Code Reuse By Inheritance

  • Tracking Changes in PHP Projects

    by Tobias Schlitt on Wed, 20 Nov 2013 09:20:39 +0100

    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. Read more on Tracking Changes in PHP Projects

  • ContainerAware Considered Harmful

    by Tobias Schlitt on Mon, 07 Oct 2013 11:25:46 +0200

    A while ago I tweeted

    ContainerAware 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. Read more on ContainerAware Considered Harmful

  • Fixing Legacy Code

    by Tobias Schlitt on Mon, 09 Sep 2013 07:07:03 +0200

    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. Read more on Fixing Legacy Code

  • Finding the right Test-Mix

    by Benjamin Eberlei on Mon, 19 Aug 2013 10:50:38 +0200

    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. Read more on Finding the right Test-Mix

  • Testing: Find the Sweet Spot

    by Tobias Schlitt on Wed, 17 Jul 2013 08:07:58 +0200

    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. Read more on Testing: Find the Sweet Spot

1 - 2 - 3 - 4 - 5