Posts Tagged ‘class builder’

Perl class builders

Monday, June 23rd, 2014

I was more than pelasantly surprised today while benchmarking Moo against Mo, Class::Tiny and Mojo::Base. It turns out the latest version of Moo doesn’t have much of a speed penality when compared to Mo or Mojo::Base. Needless to say it’s two times faster than Class::Tiny. All of this without Class::XSAccessor installed. With it installed it’s on par with Mo, sometimes even faster. If I’d start a new project today I’d probably use either Moo or Mojo::Base.

Rate ct moo mo mb
ct 76799/s -45% -50% -61%
moo 139184/s 81% -10% -29%
mo 154844/s 102% 11% -21%
mb 195491/s 155% 40% 26%

Moo only has features that make sense, such as inheritance, roles plus some safeguards that make sloppy programming a headacke. Some of them are rather annoying, for example fatal warnings, which can be defused by using Moo::Lax. If you want type checking with Moo, there are some documented extensions for that, or you can use Type::Tiny. Moo also provides an easy migration path to Moose and in order to use it you only need to install just about eight non-core dependencies, as opposed to half the CPAN.

Mojo::Base is really minimal, has zero core dependencies and is part of the excellent Mojolicious framework. If you’re already using that you probably don’t need another object builder. The syntax is also Moose-like.

Perl class builders

Saturday, October 26th, 2013

The beauty of Perl is choiceSome would argue there’s too much of it. When it comes to advanced OO features, Perl has many options to choose from. None of them are actually in the core but are available as third-party modules from CPAN. This will hopefully get fixed in the future.

One such an OO framework that is really popular among Perl developers is Moose. The problem with Moose is that it does everything and it also depends on many outside modules. But Moose led to some interesting experiments, one of which is Mo. Along with Mo, I have evaluated another minimal OO class builder for Perl, named Class::Tiny, which is in fact an Object::Tiny workalike. Confused already?

I like both class builders because they are minimal require no outside modules, so I had to test which one of them offered more useful features while still being fast. The code that I used to do this is available here. For the second test everything in the main package was wrapped inside a loop that ran 1e6 times. Current versions (Mo 0.37 and Class::Tiny 0.011) were tested on an Athlon 64 x2 box running at 1 Ghz with two gigs of RAM. Here are the results:

Mo Class::Tiny
1 run 1e6 runs 1 run 1e6 runs
real 0m0.016s
user 0m0.012s
sys 0m0.004s
real 0m20.719s
user 0m9.013s
sys 0m4.492s
real 0m0.033s
user 0m0.028s
sys 0m0.000s
real 0m28.745s
user 0m17.093s
sys 0m4.816s

As you can see, Mo turned out to be 51% faster in single runs and 28% faster when it ran multiple times. It also has some additional features, without enfocing them on the user – they have to be explicitly enabled. Mo also provides an easier and more obvious upgrade path to Moo, Mouse or Moose. It does not, however, provide multiple inheritance or a destroy method. If you need them, use Class::Tiny or Moo. Also, please keep in mind that benchmarking Mo against Class::Tiny is rather pointless because their feature set is different.

I repeated the test using Benchmark, this time appending to my favourite file descriptor. Mo came out faster by almost 50%. When writing to standard output the results are roughly the same as above. I also tested Mojo::Base, Object::Simple and Object::Tiny. They are roughly on par with one another and a tad faster than Mo, but the difference is only about 16%. Object::Tiny came out the fastest of the bunch.