Catching up on ZendCon – Echolibre

Last week our very own Helgi was at ZendCon in San José, California. He was there as a speaker to talk about Frontend Caching and “PEAR2 and Pyrus”

The first talk I gave was about frontend caching and how you can get the most speed out of your website by optimizing the various bits of the frontend.

Make sure to catch “The aftermath” on Helgi’s blog as you may get a better idea of what we do in conferences and what happens in general!

Catching up about ZendCon – Echolibre

Last week our very own Helgi was at ZendCon in San José, California. He was there as a speaker to talk about Frontend Caching and “PEAR2 and Pyrus”

The first talk I gave was about frontend caching and how you can get the most speed out of your website by optimizing the various bits of the frontend.

Make sure to catch “The aftermath” on Helgi’s blog as you may get a better idea of what we do in conferences and what happens in general!

Christian Scholz: Georg Greve’s Keynote at the Plone Conference 2009

Georg Greve from the Free Software Foundation Europe was talking about decision making. He started explaining how he moved from being a software developer to being a politician.

He takes the relicensing policy as an example and wonders how we reached a decision on it. What is a majority? How do we define the qualified majority needed? Here the Plone Foundation is one important piece. If we wouldn’t have the Plone Foundation it would come down to consensus. This works well in certain group but sometimes it also leads to shoutocracy where those people who shout the loudest go on doing so and the others at some point simply give up.

This is not applicable in many cases. E.g. in the Plone Foundation it is about copyright and you need unanimous agreement, you need everybody to say “Yes”.

Copyright Law

Copyright laws are man made by man made processes. So where does it come from?
It starts with national levels which have some form of majority. In a bi/multilateral situation it is unanimity and in the united nations it’s consensus.

This sounds as if the bi/multilateral decisions are easier to make than the UN ones but that’s not necessarily true. There are a lot of rules involved and it might come down to harsher negotiations. It is also complicated with certain regimes where they technically have 100% of their people behind them.

But why do copyright laws happen? There are always some reasons behind those laws. In copyright it is about “fairness” politicians say. But what does “fair” mean? Also politicians are not expert in this field but they still need to make decisions. So they rely on other people to help with that decision.

He gives TRIPS (Trade Related aspects of Intellectual Property Rights) as an example. Originally it was driven by a very very targeted agenda by large US corporation, by a coalition of the willing. Only those who wanted the maximum went along. And now governments need to enforce something which was created by a group of coporations. He mentions the U.S. Special 301 list with the “naughty” countries who do not enforce that.

He mentions a study (LAWRENCE) where 3 professors found out that lobby expenditures can receive you a 22,000 percent return on investment. This is for tax regulations, we don’t know about copyright lobbying. So it’s a worthwhile thing to do for companies.

On which side do you wanna be? What’s your perspective of this?

“Politics is too serious a matter to be left to politicians” (Charles de Gaulle)

The only way your voice is heard is that you need to be at that table where decisions are made. E.g. Plone is also affected by this. Like software patents, web standards, etc.

“Those who are too smart to engage in politics aree punished by being governed by those who are dumber” (Plato)

Inactivity is not an option. There are moments where we have to act!

Governance?

This is going in two directions, the external government between Plone and the outside world. But there is also the inside governance, how does the community work in itself?

Plone already decided to be a community instead of being a single vendor. He thinks that this is the more sustainable approach. The single-vendor approach is complicated because it’s only one company you don’t know the future about.

There are also other issues that come up. How do you address growth? This is one of the most challenging issue. How do we keep the substance strong as people get in and how do we ensure that our community remains able to make decisions. No one has found the answer to that yet though.

What about the structural “bottleneck bugs”?

There is things in the plumbing which you might want to redo at some point. KDE just has gone through such a process which was rather painful. Many projects encounter such situations. It is very hard to find volunteers to do that work. You also cannot find a customer to pay for all of this. There is no visual change.

How do we find ways to address those problems? He knows that the Plone community is thinking about this and he also helped the Open Database Alliance to find a solution for this. There the membership fees are done like this: 50% allocated by members, 20-30% allocated by board. Members can allocate fund for certain projects. All the members interested in this can pool their funds for this project.

In order for this to work you need the right choices. The ODBA has certain seats for users, developers etc.

Food for thought

1. Get active. Find ways to express your political agenda! Just being a small foundation of a few 100 people is not an excuse. You can make a difference!
2. The most important asset of Plone is YOU! In the end whether the PF is structured this or that way, the strategic choices still need to express what the community wants. He was positively impressed by what he experiences at the conference as he experiences a positive and lively community. Keep it that way!
3. Coordinate with your allies, like FSF. Talk to them as often as you can. Find common priorities and build alliances on them.

This live blogging report is without any guarantees of correctness and corrections are very welcome in the comments!

S. Lott: Painful Python Import Lessons

Python’s packages and modules are — generally — quite elegant.

@login_requireddef someView( request, object_id, context_from_URL ):   no_good = check_other_context( context_from_URL )   if no_good is not None: return no_good   still_no_good = check_session()   if still_no_good is not None: return still_no_good   # you get the idea

The Real Time Web explained with a Real World Example – Christian Stocker

Last week I gave 2 techtalks (one in Fribourg and one in Zurich) about how we use some of the “Real Time Web” technologies in Flux CMS and its related services. The graph for this looks like that:

And the details to this can be seen in the slides.

I also plan to write some blogposts about some of the technologies used as the blue ones in the graph are written by us and Open Source (see the links at the end of the slides). And I really hope it will end up in more than just a plan

If you want to know something in particular before I write those posts, just ask in the comments.

Eli Bendersky: Handling out-of-memory conditions in C

void *
xmalloc (size_t n)
{
  void *p = malloc (n);
  if (!p && n != 0)
    xalloc_die ();
  return p;
}

cur_path = xmalloc (cur_path_size);
strcpy (cur_path, pathname);
cur_path[pathname_len - 2] = '/';

static void *sqlite3MemMalloc(int nByte){
  sqlite3_int64 *p;
  assert( nByte>0 );
  nByte = ROUND8(nByte);
  p = malloc( nByte+8 );
  if( p ){
    p[0] = nByte;
    p++;
  }
  return (void *)p;
}

void *xmalloc(size_t size)
{
      void *ret = malloc(size);
      if (!ret && !size)
              ret = malloc(1);
      if (!ret) {
              release_pack_memory(size, -1);
              ret = malloc(size);
              if (!ret && !size)
                      ret = malloc(1);
              if (!ret)
                      die("Out of memory, malloc failed");
      }
#ifdef XMALLOC_POISON
      memset(ret, 0xA5, size);
#endif
      return ret;
}

srv_socket = calloc(1, sizeof(*srv_socket));
srv_socket->fd = -1;

kvb->ptr = malloc(kvb->size * sizeof(*kvb->ptr));

for(i = 0; i < kvb->size; i++) {
        kvb->ptr[i] = calloc(1, sizeof(**kvb->ptr));

PRIVATE acttab *acttab_alloc(void){
  acttab *p = malloc( sizeof(*p) );
  if( p==0 ){
    fprintf(stderr,"Unable to allocate memory for a new acttab.");
    exit(1);
  }
  memset(p, 0, sizeof(*p));
  return p;
}

/* Redis generally does not try to recover from out
 * of memory conditions when allocating objects or
 * strings, it is not clear if it will be possible
 * to report this condition to the client since the
 * networking layer itself is based on heap
 * allocation for send buffers, so we simply abort.
 * At least the code will be simpler to read... */
static void oom(const char *msg) {
    fprintf(stderr, "%s: Out of memory\n",msg);
    fflush(stderr);
    sleep(1);
    abort();
}

Conclusion

In this article, the various OOM policies were explained, and many examples were shown from real-world libraries and applications. It is clear that not all tools, even the commonly used ones, are perfect in terms of OOM handling. But how should I write my code?

If you’re writing a library, you most certainly should use the recovery policy. It’s impolite at the least, and rendering your library unusable at worst, to abort or dump core in case of an OOM condition. Even if the application that includes your library isn’t some high-reliability life-support controller, it may have ideas of its own for handling OOM (such as logging it somewhere central). A good library does not impose its style and idiosyncrasies on the calling application.

This makes the code a bit more difficult to write, though not by much. Library code is usually not very deeply nested, so there isn’t a lot of error propagation up the calling stack to do.

For extra points, you can allow the application to specify the allocators and error handlers your library will use. This is a good approach for ultra-flexible, customize-me-to-the-death libraries like SQLite.

If you’re writing an application, you have more choices. I’ll be bold and say that if your application needs to be so reliable that it must recover from OOM in a graceful manner, you are probably a programmer too advanced to benefit from this article. Anyway, recovery techniques are out of scope here.

Otherwise, IMHO the abort policy is the best approach. Wrap your allocation functions with some wrapper that aborts on OOM – this will save you a lot of error checking code in your main logic. The wrapper does more: it provides a viable path to scale up in the future, if required. Perhaps when your application grows more complex you’ll want some kind of gentle recovery like Git does – if all the allocations in your application go through a wrapper, the change will be very easy to implement.

[1]

The documentation of g_error states: A convenience function/macro to log an error message. Error messages are always fatal, resulting in a call to abort() to terminate the application. This function will result in a core dump; don’t use it for errors you expect. Using this function indicates a bug in your program, i.e. an assertion failure.

[2]	Embedded in the sense that it can be embedded into other applications. Just link to the 500K DLL and use the convenient and powerful API – and you have a fast and robust database engine in your application.

[3]	Here’s the size-checking function from the same file:

static int sqlite3MemSize(void *pPrior){
  sqlite3_int64 *p;
  if( pPrior==0 ) return 0;
  p = (sqlite3_int64*)pPrior;
  p--;
  return (int)p[0];
}

[4]	I’ve reformatted it to fit on the blog page without horizontal scrolling.

Related posts:

1. Using goto for error handling in C Introduction We would all like to write nice and…

what is pod weaver? (pt. 1: secret origins)

One or two people who write Pod regularly said, “Yeah, I saw you blogging about
that Pod thing. I had no idea what you were talking about.” A few other
people said, “neat, but how do I use it?” Its documentation is getting better,
but here’s a crash…

Ted Leung: The LumaLoop

Back in September, my friend James Duncan Davidson stopped to visit me and the family here on Bainbridge Island. Duncan has been working on a new design for a camera strap, and during that visit he showed me one of the prototypes of the LumaLoop. I spent a good portion of our time playing with the strap, and was quite taken with the design. Needless to say, I didn’t really want to give it back to him when it was time for him to go.

The following week at DjangoCon, I lost the strap portion of my Upstrap quick release strap. I liked the Upstrap, but it wasn’t ideal. The Upstrap was great because of the non stick rubber pad that they use – it really won’t move. But like most other camera straps, I found that I was constantly getting it fouled in my arms or something, especially between landscape and portrait modes.

Duncan had promised me one of the early prototypes of the LumaLoop, so I put the official black and neon yellow strap on the D3 and waited patiently. Yesterday, my LumaLoop arrived, and I quickly installed it in place of the Nikon strap. The LumaLoop is a “sling strap” similar to the Black Rapid R-Straps that have become popular recently. The Black Rapid straps screw into the tripod socket on your camera, which is a problem if you have any kind of heavy duty tripod plate mounted on your camera, or if you shoot vertically a lot (this is even more of a problem if you have small hands and a camera with a battery grip). The LumaLoop attaches to one of the regular strap mounts on your camera, and once attached, you can slide the camera up and down the strap. The mounting loop is attached with a quick release clip, so swapping cameras/straps is easy as well. Duncan has a series of blog posts that detail the reasoning behind the design:

• Hacking the R-Strap
• Camera Strap Update 1
• Camera Strap Update 2

Here’s a quick snapshot of mine:

You can see the loop part that goes on the camera, as well as the quick release between the loop and the rest of the strap. It’s a bit harder see the padded non-slip shoulder pad.

The LumaLoop is going to be available from Luma Labs sometime very soon (Duncan gave me perimission to talk about the LumaLoop in advance of its general availability). You can follow Luma Labs on Twitter to keep up with all of the news and the official announcement. I’m excited to have a strap that both holds my camera securely and stays out of my way when the action gets going.

(Unmoderated) manual notes are bad, mmkay? – Adam Harvey

I’ve had a couple of whinges on IRC lately about why I’m not thrilled with having user notes in their current form in the PHP manual; we get entirely too many questions in ##php from people who’ve copied code out of a note and are then annoyed when it turns out the code is wrong, broken, horrible, or all of the above.

I present this example from the DateTime::getTimestamp() manual page. It’ll be disappearing from the mirrors over the next few hours, because I’ve deleted it (and posted a much simpler note in its place), so here was its content, for posterity:

If you are using PHP < 5.3.0 you can use this function instead:

<?php
function DateTime_getTimestamp(&$dt) {
$dtz_original = $dt -> getTimezone();
$dtz_utc = new DateTimeZone("UTC");
$dt -> setTimezone($dtz_utc);
$year = intval($dt -> format("Y"));
$month = intval($dt -> format("n"));
$day = intval($dt -> format("j"));
$hour = intval($dt -> format("G"));
$minute = intval($dt -> format("i"));
$second = intval($dt -> format("s"));
$dt -> setTimezone($dtz_original);
return gmmktime($hour,$minute,$second,$month,$day,$year);
}
?>

It’s fair to say that’s an interesting approach. The normal way of doing it would be:

<?php $timestamp = $dt->format('U'); ?>

I don’t know what the answer is — moderation has its own problems to do with workload, as PEAR can attest — but a system that’s letting that go up as recommended practice (and stay up for a month) has to be looked at.

Q&A: Answering Some Questions About Object-Oriented Programming – Brandon Savage

Last week I wrote about five tips to improve object-oriented code. This generated a number of important questions, which I will attempt to answer for those who asked them.

“Often times when a developer gives each object only one responsibility, they tightly couple objects together.” Can you explain?
There are two major pitfalls in object-oriented programming: trying to do too much with an object, and trying to couple a number of objects too closely together. For this example, we’ll use the engine metaphor.

<?php

class Engine {
protected $crankshaft;
protected $pistons;
protected $radiator;

public function __construct()
{
$this->crankshaft = new Crankshaft($this);
$this->pistons[] = new Piston($this);
$this->pistons[] = new Piston($this);
$this->pistons[] = new Piston($this);
$this->pistons[] = new Piston($this);
$this->radiator = new Radiator($this);
}
}

In the above example, the Engine has one job: to direct the function of the crankshaft, pistons and radiator in order to move an automobile along. But we have a couple of fatal flaws. The first fatal flaw is that we pass the Crankshaft, Pistons and Radiator a copy of the Engine; while this might make development easy at some point (because the Radiator can send messages to the Engine) it is a poor design. It’s a poor design because the Engine controls the components, not the other way around. Additionally, we are instantiating the Crankshaft, Pistons and Radiator inside our constructor method, which means that the same Crankshaft, Piston and Radiator classes be available wherever we go. Let’s decouple this and fix it.

<?php

class Engine {
protected $crankshaft;
protected $pistons;
protected $radiator;

public function __construct(CrankshaftI $crankshaft, array $pistons, RadiatorI $radiator)
{
$this->crankshaft = $crankshaft;
foreach($pistons as $piston) {
if(!($piston instanceof PistonI) {
throw new EngineException('Improper piston type used');
}
$this->pistons[] = $piston;
}
$this->radiator = $radiator
}
}

How is this an improvement? First, we make use of dependency injection in our constructor: rather than automatically creating new objects, we expect that the objects have already been created and are being “installed” (injected) into our Engine. Second, we require that the objects utilize a certain interface. Now, some might argue that this is still tight coupling but I disagree: while you must have the interface available to you, interfaces do not define function. They simply define the methods that are available and must have been defined.

In this case, you can pull these interfaces and the Engine class out and build the library elsewhere, so long as you include the various methods of CrankshaftI, PistonI and RadiatorI. This is acceptable because every Piston will have certain methods (fire, upSwing, downSwing, injectFuel) but the functionality can be different depending on the type of piston you want.

This also gives every object its own job. The Piston is only responsible for doing Piston-related tasks; the Engine is responsible for controlling the Piston, but not executing its specific job functions. The Piston doesn’t have to be smart about the Engine or know about the Radiator; it only needs to know about its job. And so, each object has only one clearly defined role.

I do not know about dependency injection – do you have any links that do not require subscription?
I’ll talk about Dependency Injection here. It’s actually a really simple topic.

Since PHP 5, when you pass an object into a function, class, or by value, what you’re actually doing is passing it in a reference-like state. I say “reference-like” because it behaves somewhat like a reference but somewhat not (to learn more read this). When you act on the object, you change the object globally – that is, all instances of the object are changed. This is because when you pass an object by value you’re not copying the object; you’re simply passing the internal PHP value tha

Truncated by Planet PHP, read more at the original (another 3230 bytes)

Recently Written

• Should Module::Install move to explicit plugin declaration?
• Hector Garcia: FlacComp (FLAC Compilation)
• Chris Leary: A prototypal binding trap
• Mario Boikov: IcecastRadio – Qt widget/Qt Quick example Icecast player
• Doug Hellmann: PyMOTW: re – Regular Expressions
• Richard Tew: Roguelike MUD progress #3
• Richard Tew: Roguelike MUD progress #2
• Richard Tew: Roguelike MUD progress
• PHP segfaulting with pecl/uuid and pecl/imagick – Lars Strojny
• Ned Batchelder: Making good tar files on Windows

Categories

• Directory
• Planet
• Uncategorized

Archives

• September 2010
• August 2010
• July 2010
• June 2010
• May 2010
• April 2010
• March 2010
• February 2010
• January 2010
• December 2009
• November 2009
• October 2009
• September 2009
• August 2009
• July 2009

Blogroll

• Development Blog
• Documentation
• Planet Perl
• Planet PHP - People blogging about PHP
• Planet Python - Planet Python – http://planet.python.org/
• Plugins
• Suggest Ideas
• Support Forum
• Themes
• WordPress Planet