Самым полезным, для меня, оказался инструмент Copy/Paste Detector for PHP code. Как ясно из названия, этот инструмент используется для дублирующегося кода, ярым поборником которого я являюсь.

Устанавливается он очень просто, как PEAR пакет:

sb@ubuntu ~ % pear channel-discover pear.phpunit.de
Adding Channel "pear.phpunit.de" succeeded
Discovery of channel "pear.phpunit.de" succeeded

sb@ubuntu ~ % pear channel-discover components.ez.no
Adding Channel "components.ez.no" succeeded
Discovery of channel "components.ez.no" succeeded

sb@ubuntu ~ % pear install phpunit/phpcpd
downloading phpcpd-1.3.0.tgz ...
Starting to download phpcpd-1.3.0.tgz (7,809 bytes)
.....done: 7,809 bytes
downloading File_Iterator-1.1.0.tgz ...
Starting to download File_Iterator-1.1.0.tgz (3,181 bytes)
...done: 3,181 bytes
downloading ConsoleTools-1.6.tgz ...
Starting to download ConsoleTools-1.6.tgz (869,925 bytes)
.........................................................
.........................................................
.........................................................
..done: 869,925 bytes
downloading Base-1.8.tgz ...
Starting to download Base-1.8.tgz (236,357 bytes)
...done: 236,357 bytes
install ok: channel://components.ez.no/Base-1.8
install ok: channel://components.ez.no/ConsoleTools-1.6
install ok: channel://pear.phpunit.de/File_Iterator-1
install ok: channel://pear.phpunit.de/phpcpd-1.3.0

Пользоваться, тоже, — очень просто:

bash-3.2# phpcpd PEAR/tests/
phpcpd 1.3.1 by Sebastian Bergmann.

Found 5 exact clones with 85 duplicated lines in 5 files:

  - MDB2/tests/MDB2_extended_testcase.php:398-404
    MDB2/tests/MDB2_extended_testcase.php:453-459

  - MDB2/tests/MDB2_manager_testcase.php:61-75
    MDB2/tests/MDB2_reverse_testcase.php:86-100

  - MDB2/tests/MDB2_usage_testcase.php:1289-1321
    MDB2/tests/MDB2_usage_testcase.php:1577-1609

  - MDB2/tests/MDB2_usage_testcase.php:1567-1593
    MDB2/tests/MDB2_usage_testcase.php:1739-1765

  - Structures_Graph/tests/testCase/BasicGraph.php:111-118
    Structures_Graph/tests/testCase/BasicGraph.php:142-149

Еще один полезный инструмент, это PHP Depend. Он позволяет взглянуть на ваш проект, как бы, с «высоты птичьего полета», предоставляя такие метрики как: количество строк кода, классов, пакетов, методов, вызовов и даже эмпирическую метрику «сложность кода». Здесь можно прочитать расшифровку всех показателей.

Я сравнил два довольно больших проекта, которые веду и метрики отразили в цифрах почти то же что и было «по ощущению», — более новый проект проще и лучше приблизительно в 2-3 раза, при том что имеет более сложную бизнес логику и функционал:

Следующий, хороший инструмент это PHP Mess detector. Устанавливается он аналогично, с помощью PEAR installer:

mapi@arwen ~ $ pear channel-discover pear.phpmd.org
mapi@arwen ~ $ pear channel-discover pear.pdepend.org
mapi@arwen ~ $ pear install --alldeps phpmd/PHP_PMD-alpha

Эта утилита дает нам массу интересной информации для размышления:

bash-3.2# phpmd PEAR/Pear.php text codesize

PEAR.php:87	This class has a bunch of public methods and attributes
PEAR.php:87	This class has too many methods, consider refactoring it.
PEAR.php:87	This class PEAR has an overall complexity of 102 which is very high. The configured complexity threshold is 50.
PEAR.php:323	The method setErrorHandling() has a Cyclomatic Complexity of 11.
PEAR.php:511	The method raiseError() has a Cyclomatic Complexity of 20.
PEAR.php:511	The method raiseError() has an NPath complexity of 1600.
PEAR.php:771	The function _PEAR_call_destructors() has a Cyclomatic Complexity of 12.
PEAR.php:831	This class has a bunch of public methods and attributes
PEAR.php:866	The method PEAR_Error() has a Cyclomatic Complexity of 19.
PEAR.php:866	The method PEAR_Error() has an NPath complexity of 11520.

bash-3.2# phpmd PEAR/Pear.php text unusedcode

PEAR.php:450	Avoid unused local variables such as '$key'.
PEAR.php:788	Avoid unused local variables such as '$k'.

Здесь важно насколько много проблемных мест в вашем коде. Изучая подобные отчеты вы будете всегда видеть какие части приложения должны быть подвергнуты рефакторингу в первую очередь.

Похожий по своему применению инструмент PHP_CodeSniffer, позволяет оценить насколько ваш код соответствует стандартам кодирования.

Итак, всемирная паутина продолжает развиваться. С одной стороны, объёмы существующей информации, огромны и кардинальные изменения происходят медленнее, в силу того, что для изменения нужно затрачивать больше усилия. С другой стороны, именно благодаря масштабу и размаху существующие проблемы становятся очивиднее. Информации становится больше, и найти нужную, упорядочить её становится всё сложнее. Тим Бернерс-Ли, изобретатель существующей версии интернета предлагает свою версию обновленного интернета, называя его Семантической Сетью. Идея новой модели немного непривычно ложится на существующие стереотипы понимания сети. Смысл его в том что документы это не голый текст, а какой-то смысл, изложенный текстом на каком-то языке, или еще шире, графика, видео, суть неважно. Научив машины «понимать» этот смысл мы сможем оперировать с информацией на более высоком уровне, — например делать умозаключения, искать неочевидные решения, избегать излишнего дублирования информации и многое другое. Я сейчас не хочу говорить о том насколько реалистичным является построение Семантической Сети в ближайшее время, пусть копья ломают те, у кого есть на это время и силы, но в узких прикладных областях (например в экспертных системах), эти идеи уже нашли свое применение.

Это классическая иллюстрация, описывающая пирамиду идей, на которых строится Семантическая паутина. Видно что в центре идеи находятся онтологии OWL, описывающие взаимосвязи между понятиями (URI). Неймспейсы (namespaces) поволяют одни и те же понятия описывать по разному в рамках разных предметных областей. RDF предлагает простой способ описания взаимосвязей между понятиями в виде троек (триплетов): субъект — предикат — объект. Вот примеры таких троек:

• крушовице — чешское — пиво
• чешское — очень хорошее — пиво
• Иннокентий — любит — пиво

В этом примере интересно что основываясь на этих данных машина может делать некоторые предположения, — например о том, что Иннокентию, скорее всего, понравится крушовице. То что мы только делаем предположения относительно результата, а не гарантируем его, может смутить, но на самом деле вся информация в сети, это просто предположения а не факты в последней инстанции. OWL расширяет семантику и логику «троек» до классов с описанием взаимодействий внутри этих классов, причем класс может быть определен разными способами:

• идентификатором класса (URI)
• перечислением всех экземпляров класса
• ограничением свойства
• пересечением 2 и более определений классов
• объединением 2 и более определений классов
• дополнением определения класса

OWL описывает классами предметную область, языком которой можно описать факты, касающиеся предметной области.

Есть два видения развития сети, — первый это постепенное создание онтологий вокруг существующих предметных областей (медицина, право и т.д.), второй — это построение синтаксических анализаторов, способных разбирать обычные тексты и строить онтологии на основании предположений записанных обычным, человеческим языком. При всей футуристичности второго подхода существуют довольно интересные наработки в эту сторону, например WordNet.

Надо сказать что шум вокруг Semantic Web докатился и до PHP. ARC развивается с конца 2007 года и, превратился в весьма функциональный инструмент. Вот неполный перечень того что умеет ARC:

• Web Reader, для построения ботов с поддержкой проки и редиректов
• Парсеры: RDF/XML, Turtle, SPARQL + SPOG, Legacy XML, HTML tag soup, RSS 2.0, Google Social Graph API JSON
• Сериализаторы: N-Triples, RDF/JSON, RDF/XML, Turtle, SPOG dumps
• Сохранение RDF в mysql базу (SPARQL SELECT, ASK, DESCRIBE, CONSTRUCT, + aggregates, LOAD, INSERT, and DELETE)
• RDF экстракторы (DC, eRDF, microformats, OpenID, RDFa)
• Поддержка SPARQL

Код у библиотеки шикарный, и отлаживаться-расширятся она должна очень легко. Но, как говорится, лучше один раз увидеть чем сто раз услышать, — приведу несколько примеров её использования:

include_once('arc/ARC2.php');
 
$parser = ARC2::getRDFParser();
$parser->parse('http://www.w3.org/TR/owl-guide/wine.rdf'); // загружаем онтологию
var_dump($parser->getTriples()); // получаем массив "троек" онтологий вида:

array(2012) {
  [0]=>
  array(7) {
    ["s"]=>
    string(52) "http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine"
    ["p"]=>
    string(47) "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
    ["o"]=>
    string(38) "http://www.w3.org/2002/07/owl#Ontology"
    ["s_type"]=>
    string(3) "uri"
    ["o_type"]=>
    string(3) "uri"
    ["o_datatype"]=>
    string(0) ""
    ["o_lang"]=>
    string(0) ""
  }
...

Загруженную онтологию или RDF можно сохранить в N-Triples, RDF/JSON и даже HTML:

$ser = ARC2::getSer('LegacyHTML');
echo $ser->getSerializedArray($triples);

Но самое интересное, что позволяет ARC, это безусловно SPARQL:

$config = array(
	/* db */
	'db_host' => 'localhost',
	'db_name' => 'db_name',
	'db_user' => 'user',
	'db_pwd' => 'password',
);
 
$store = ARC2::getStore($config);
 
if (!$store->isSetUp()) { // проверяем инициализацию базы
  $store->setUp(); //  если таблицы не были созданы, - они создаются
}
 
$store->query("PREFIX base:
INSERT INTO base:Graph {
	base:testEntity1 base:testPredicate1 'test object 1' .
	base:testEntity1 base:testPredicate2 base:testEntity3 .
	base:testEntity2 base:testPredicate1 'test object 2' .
	base:testEntity2 base:testPredicate2 base:testEntity4 .
	base:testEntity3 rdf:type base:Type1 .
	base:testEntity4 rdf:type base:Type2 .
}
"); // выполняем запрос на добавление "троек"
 
$store->query('SELECT *
WHERE {
	?obj ?predic "test object 1" .
}'); // выполняем запрос

Для того чтобы попробовать «поиграть» с элементами семантического веба, в ваших приложениях, функционала ARC вполне достаточно. Ну а если вы всерьез заинтересуетесь этой темой, рекомендую обратить внимание на открытый проект Jena.

import time
import threading
 
class Test:
 
    def __init__(self):
        self.data = 0
        self.lock = threading.Lock()
 
    def process(self, value):
        for i in xrange(10):
            self.lock.acquire()
            self.data += 1
            print(value),
            print(i),
            print(self.data)
            self.lock.release()
            time.sleep(1)
 
    def run(self):
        pool = threading.BoundedSemaphore(value=2)
        for i in xrange(3):
            pool.acquire()
            proc = threading.Thread(target=self.process, name="p" + str(i), args=[i])
            proc.start()
            pool.release()
 
test = Test()
test.run()
 
0 0 1
1 0 2
2 0 3
0 1 4
1 1 5
2 1 6
1 2 7
0 2 8
2 2 9
1 3 10

Правда, изящно?

UPDATE:
К сожалению, запросто переписав мою систему на запуск в несколько потоков никакого прироста производительности не обнаружилось, скорее наоборот, а питон как работал на одном CPU так и работает. Первая же ссылка подтвердила догадку:

The C implementation of Python uses a global interpreter lock that only
allows one thread to interpret bytecode at a time, so while the threads may
be distributed across multiple processors you will get little or no speedup
over a single processor. (If your threads spend most of their time in a
non-Python extension, they may be able to get some benefit from multiple
processors).

The only way to take advantage of multiple processors with Python is to run
at least one separate process for each processor.

Что в переводе означает: "волшебства не бывает, брат"

Поскольку доски у нас нет, ну как-то не сложилось, да мы больше тяготеем к онлайновым инструментам для совместной работы было решено допилить к мантису желаемый функционал. Заняло это, от силы, часа полтора времени, львиную долю которого было потрачено на выбор приятных глазу стилей. Получилось, вот так:

Для тех кто не знает что это такое: жизнь любой задачи (желтого стикера), в проекте (на доске), это движение слева направо через такие пункты как «назначено», «выполняется», «завершено», «протестировано», «закрыто». Таким образом можно легко ориентироваться в потоке небольших задач, свойственных веб разработке.

Исходный код скрипта, прилагается.

Сразу скажу что php язык хороший, и написать на нем можно всё, но не всё можно написать одинаково хорошо, быстро, и без лишних проблем в перспективе развития проекта. Т.е. для домашней странички-форума-блога, — да, шикарное решение, а для разработки сложного корпоративного софта, с большим количеством частоизменяющихся бизнес требований, веб приложений под нагрузками, как мне кажется, можно найти более подходящий инструмент. Конечно, идеально использование java/.net, но поскольку не все проекты у нас большие, а технологии эти довольно тяжелы для «подъёма» в эту сторону пока смотреть не хочется. В этом цвете мне и приглянулся haxe. С одной стороны — шикарный язык, в лучших традициях java/c#, с другой, — не перегруженный, простой для понимания и освоения php программистами. Главная идея haxe, — это различные платформы на выходе: c++, neko, javascript, php, flash, что дает массу гибкости и при хорошо организованной архитектуре позволит безболезненно переводить уже написанное приложение с платформы на платформу, в зависимости от нужд. Со списком преимуществ haxe можно познакомится здесь. Это в теории, на практике, конечно же нужно что-то делать с платформозависимыми библиотеками, либо писать заведомо ограниченные приложения.

Ну чтож, перейдем к самому интересному, — бенчмаркам. Ничего особо сложного тестировать я не хотел, написал простой тест, который включает в себя создание локальных переменных, простейшие операции, циклы, сравнения. Это то что мы чаще всего пишем в коде. Мне было интересно сравинить скорость выполнения чистого php, разницы в скорости вызовов функций перед статическими методами класса, разницы выполнения в консоли и через модуль apache, haxe кода скомпилированного в php и производительности nekovm.

Вот что получилось:

Выводы: скомпилированный php код не намного уступает обычному php коду. Вполне очевидно что код nekovm выполняется быстрее чем php, благодаря строгой типизации и прочим фичам. Разница в выполнении из консоли или через апач видна только в nekovm, из-за того что скорость выполнения значительно выше чем php. Несмотря на то что haxe платформа довольно молодая, перспективы у неё огромные. Возможность относительно легко мигрировать приложеня с php в nekovm мне кажется пока усложнена отсутствием высокопроизводительного движка шаблонов (в php с этим отлично справляется pure php), но уже сейчас стоит обратить внимание на такие возможности как SPOD (объектная работа с базой данных), многопоточное программирование, интеграция с кодом на C

Исходный код тестов

Вот как это выглядит:

Так выглядят коммиты CVS в mantis

К viewvc мы прикрутили SyntaxHighlighter, и код стал на порядок читабельнее:

просмотр кода с ViewVC и SyntaxHighlighter

Для тех кто заинтересовался, прилагаю измененные мною файлы мантиса: mantis_patch_for_cvs_support. Возникнут вопросы - спрашивайте.

 
# инициализация переменных
 
a, b = 3, 4
print(a + b)
 
>7
 

 
 
# последовательные вызовы
 
open("out.txt", 'w').writelines(i.lower() for i in open("input.txt", 'r'))
 

 
 
# lambda функции
 
from math import sqrt
 
a = lambda x, y : sqrt(x**2 + y**2)
print a(2, 2)
 
> 2.82842712475
 

 
 
# собственные операции над экземплярами классов, в данном случае сравнение
 
class MyString:
    def __init__(self, str):
        self.str = str        
 
    def __cmp__(self, str):
        return cmp(len(self.str), len(str.str))
 
print(MyString("a") > MyString("abc"))
 
> False
 

 
 
# множественное наследование
 
class A:
    def a(self):
        return "a"
 
class B:
    def b(self):
        return "b"
 
class C(A,B):
    def c(self):
        return self.a() + self.b()
 
test = C()
print test.c()
 
> ab
 

 
 
# классы-итераторы
 
from random import random
 
class RandomArray:    
 
    def __init__(self, len):
        self.lst = [random() for i in range(len + 1)]
        self.current = 0
 
    def __iter__(self):
        return self
 
    def next(self):
        self.current += 1
        if len(self.lst) > self.current:
            return self.lst[self.current]
        else:
            raise StopIteration
 
for i in RandomArray(3):
    print i 
 
> 0.756338496947
> 0.0337045293883
> 0.50394288767
 

 
 
# синтаксис привычного in_array()
 
arr = [1, 2, 3]
print(1 in arr)
print(4 in arr)
 
> True
> False
 

 
 
# метаклассы, своего рода ООП-пластелин
# надо сказать что весь код на Python напоминает мне пластелин
 
def classFactory(func):
    class X(object):
        pass
    setattr(X, func.__name__, func)
    return X
 
def my_method(self):
    print "I am here"
 
MyClass = classFactory(my_method)
my_object = MyClass()
my_object.my_method()
 
> I am here
 

 
 
# операции с массивами
 
arr = [1, 2, 3, 4, 5]
print(arr[:2])
print(arr[2:])
print(arr[:-2])
print(arr[-2:])
print(arr[::2])
 
> [1, 2]
> [3, 4, 5]
> [1, 2, 3]
> [4, 5]
> [1, 3, 5]
 

 
 
# аналогичные операции со строками
 
str = "abcdefg"
print(str[2:])
str = "abcdefg"
print(str[:1])
 
> cdefg
> a
 

 
 
# работа с потоками
 
import threading
from time import sleep
 
def proc(n):
    print "Process", n
    for i in xrange(3):
        sleep(float(n))
        print n + " : " + str(i)
 
p1 = threading.Thread(target=proc, name="t1", args=["1"])
p2 = threading.Thread(target=proc, name="t2", args=["2"])
p1.start()
p2.start()
 
> Process 1
> Process 2
> 1 : 0
> 2 : 0
> 1 : 1
> 1 : 2
> 2 : 1
> 2 : 2
 

 
 
# системные вызовы - запросто
 
from winsound import Beep
from random import randrange
 
for i in range(50):
    Beep(randrange(100, 1000), 100)
 

 
 
# дебагер "из коробки". его красота не столько в функциональности,
# столько в том что на питоне это весьма просто реализовывается
 
import pdb
 
def fun(s):
    lst = []
    for i in s:
        lst.append(ord(i))
    return lst
 
pdb.runcall(fun, "ABCDE")
 
> c:\main.py(35)fun()
-> lst = []
(Pdb) n
> c:\main.py(36)fun()
-> for i in s:
(Pdb) n
> c:\main.py(37)fun()
-> lst.append(ord(i))
(Pdb) print i
A
(Pdb) n
 

 
 
# профайлер из коробки, тоже, как по мне - очень круто
 
import profile
from math import sqrt
 
def print_close_matches():
    arr = []
    for i in range(1000):
        arr.append(sqrt(i**3))
    return arr
 
profile.run(r'print_close_matches()')
 
         2005 function calls in 0.051 CPU seconds
 
   Ordered by: standard name
 
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1000    0.001    0.000    0.001    0.000 :0(append)
        1    0.000    0.000    0.000    0.000 :0(range)
        1    0.045    0.045    0.045    0.045 :0(setprofile)
     1000    0.001    0.000    0.001    0.000 :0(sqrt)
        1    0.000    0.000    0.006    0.006 <string>:1(<module>)
        1    0.003    0.003    0.006    0.006 main.py:7(print_close_matches)
        1    0.000    0.000    0.051    0.051 profile:0(print_close_matches())
        0    0.000             0.000          profile:0(profiler)
 
</module></string>

Результат работы на java:

java -Xmx256m -jar tester.jar
7.813sec
142Mb

Результат работы на php:

php test.php
6.19590497017sec
118.501411438Mb

Исходники можно скачать здесь.