Инструкция по эксплуатации:

Usage: site_down_notifier.py -s http://site.com -n email@site.com
Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -s SITE, --site=SITE  define site for monitoring (url like http://site.com/)
  -n EMAILS, --notify=EMAILS
                        emails for notification (comma separated)
  -r STR, --str=STR     phrase for checking on your site page
  -t TLS, --mailtls=TLS
                        use secure email connection (True/1, False/0)
  -m SERVER, --mailserver=SERVER
                        mail server (smtp.gmail.com)
  -p PORT, --mailport=PORT
                        smtp port of mail server (25)
  -w PASSWORD, --mailpass=PASSWORD
                        password for mail server
  -b EMAIL, --mailbox=EMAIL
                        account for mail server

Исходный код скрипта:

 
 
#! /usr/bin/python
 
import smtplib
import httplib
import sys
import re
from optparse import OptionParser
from pprint import pprint
 
class GMailer:
 
    def __init__(self, server, port, login, password, tls = False):
        if tls:
            self._server = smtplib.SMTP_SSL(server, port)
        else:
            self._server = smtplib.SMTP(server, port)
 
        self._login = login
        self._server.set_debuglevel(1)
        self._server.login(login, password)
 
    def send(self, to, subject, message):
        msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n%s"
               % (self._login, to, subject, message))
 
        return self._server.sendmail(self._login, to, msg) 
 
    def close(self):
        self._server.quit()
 
parser = OptionParser(usage = "%prog -s http://site.com -n email@site.com", version="%prog 1.0")
parser.add_option("-s", "--site", dest="site",help="define site for monitoring (url like http://site.com/)", metavar="SITE")
parser.add_option("-n", "--notify", dest="emails", help="emails for notification (comma separated)", metavar="EMAILS")
parser.add_option("-r", "--str", dest="sitestr", help="phrase for checking on your site page", metavar="STR", default = "")
parser.add_option("-t", "--mailtls", dest="tls", help="use secure email connection (True/1, False/0)", metavar="TLS", default=False)
parser.add_option("-m", "--mailserver", dest="mailserver", help="mail server (smtp.gmail.com)", metavar="SERVER")
parser.add_option("-p", "--mailport", dest="mailport", help="smtp port of mail server (25)", metavar="PORT", default=25)
parser.add_option("-w", "--mailpass", dest="mailpass", help="password for mail server", metavar="PASSWORD")
parser.add_option("-b", "--mailbox", dest="mailbox", help="account for mail server", metavar="EMAIL")
 
(options, args) = parser.parse_args()
 
if options.site and options.emails and options.mailserver and options.mailpass:
    error = ""
 
    result = re.search("^(http|https)://([\w.-]*)(.*)", options.site)
 
    if result.lastindex < 3:
        print("Wrong url: %s" % (options.site))
        exit()
    else:
        try:
            if result.group(1) == "https":
                conn = httplib.HTTPSConnection(result.group(2), timeout=100)
            else:
                conn = httplib.HTTPConnection(result.group(2), timeout=100)
            conn.request("GET", result.group(3))
            r1 = conn.getresponse()    
 
            if(r1.status != 200):
                error = "host unavailable"
            elif (options.sitestr != "") and (r1.read().find(options.sitestr) <= 0):
                error = "wrong content on home"
        except:
            error = "host not found"
 
        if error != "":
            mailer = GMailer(options.mailserver, options.mailport, options.mailbox, options.mailpass, options.tls)
            for email in options.emails.split(","):
                if mailer.send(email, "psycare", error):
                    print("Report to %s sent" % (email))
            mailer.close()
            print("errors sent")
        else:
            print("everything is ok")
else:
    print "not enough parameters"
 

Первый проект о котором стоит рассказать это freebase.com, своего рода википедия, построенная по канонам Semantic Web. Сложно даже назвать это проектом, — это целая платформа, позволяющая строить на ней свои приложения, прямо в броузере, используя довольно функциональную IDE:

Разработчики отказались от использования SPARQL, в пользу более функционального, по их мнению, json-подобного собственного языка запросов. Поэкспериментировать с ним можно прямо в броузере. А с помощью этого приложения можно изучить внутреннюю структуру данных freebase. Есть даже примеры весьма функциональных приложений, например своеобразный навигатор в мире кино:

Насколько я понял, база данных пополняется силами энтузиастов а также, из открытых онтологий. Сам проект имеет открытое API для разработчиков, создатели активно пишут в блоге о планах, технических аспектах и многом другом. В общем проект интересный, всем рекомендую, хотя бы взглянуть.

Второй любопытный проект, — это dbpedia.org, сообщество энтузиастов, занимающихся структурированием информации из википедии. Он не такой красивый как freebase, и местами вылетают ошибки, но тем не менее, есть в нем своя прелесть, взять хотя бы приложение relfinder, флексовое приложение, отображающее связи между сущностями:

 
import flash.display.Sprite;
 
function onFrame(e: Event) {
	trace(System.totalMemory);
	var test = new Sprite();
}
 
addEventListener(Event.ENTER_FRAME, onFrame)
 

Запустив его вы убедитесь что плеер выделяет всё больше и больше памяти для себя, и спустя какое-то время, - начинает освобождать. То есть, память очищается не сразу же, как только на объект все ссылки удалены, а только через какое-то время. Графически это выглядит так:

Сборку мусора можно запустить принудительно в debug версии плеера так:

 
System.gc();
 

А в обычном плеере, можно воспользоваться хаком:

 
try {
    new LocalConnection().connect('foo');
    new LocalConnection().connect('foo');
} catch (e:Error) {}
 

Можно сделать несколько выводов:

1. Я не показал этого в коде, но на самом деле память начинала расходоваться только с объектов Sprite. Объекты классов int, Number, Object удалялись сразу же.
2. Мы не имеем контроля над управлением памятью, поэтому есть смысл делать пул объектов, запрашивая экземпляры нужных классов, по мере надобности, периодически подчищая пул. Таким образом мы по крайней мере будем удерживать количество занимаемой памяти, особенно в случае если большое количество объектов создается-удаляется (а в идеале избегать этого).
3. За памятью нужно постоянно следить, иначе потом будет очень непросто разобраться в чем именно проблема

Более подробно про работу Garbage Collector можно прочитать в статье Гранта Скиннера, он же, пишет про хак, на своем сайте.

Поскольку на flash/flex мы чаще всего делаем  интерфейсы, мне в первую очередь было интересно как тестировать асинхронные вызовы, элементы UI, и проч. Я написал небольшой класс, представляющий из себя сильно упрощенную версию конвеера Жени Потапенко. Вот код двух классов:

// Task.as
 
package com.sheremetov.manager {
	public class Task {
 
		private var _func: Function;
		private var _time: int;
		private var _params: Object;		
 
		public function Task(func: Function, time: int, params: Object = null) {
			_func = func;
			_time = time;
			_params = params;
		}
 
		public function get caller(): Object {
			return caller;
		}
 
		public function get params(): Object {
			return _params;
		}
 
		public function get time(): int {
			return _time;
		}
 
		public function get func(): Function {
			return _func;
		}
 
	}
}

// Conveyor.as
package com.sheremetov.manager
{
	import flash.events.TimerEvent;
	import flash.utils.Timer;
 
	public class Conveyor { 
 
		private var _queue: Array;
		private var _timer: Timer;
 
		private var _paused: Boolean = false;
 
		public function Conveyor() {
			_queue = new Array();
			_timer = new Timer(1,1);
			_timer.addEventListener(TimerEvent.TIMER, onTaskFinished);
		}
 
		public function add(task:Task): void {
			_queue.push(task);
		}		
 
		public function play(): void {
			runCurrent();
		}
 
		public function stop(): void {
			_timer.stop();
		}
 
		private function runCurrent(): void {
			if(_queue.length > 0) {
				var task: Task = _queue.shift();
				if(task.params != null) {
					task.func(task.params);
				} else {
					task.func(null);
				}
				_timer.delay = task.time;
				_timer.start();
			}
		}
 
		private function onTaskFinished(event: TimerEvent): void {
			runCurrent();
		}
	}
}

Первое с чего надо начать для тестирования этого кода это TestSuite и TestRunner, который будет его запускать:

// ConveyorTestSuite.as
package com.sheremetov.manager.tests {
 
	[Suite]
           [RunWith("org.flexunit.runners.Suite")]
	public class ConveyorTestSuite {		
 
		public var conveyorTest: ConveyorTest;
		public var taskTest: TaskTest;
 
		public function ConveyorTestSuite() {
 
		}
	}
}

Runner.mxml

 
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application
    xmlns:mx="http://www.adobe.com/2006/mxml"
    xmlns:flexunit="flexunit.flexui.*"
    xmlns:flexUnitUIRunner="http://www.adobe.com/2009/flexUnitUIRunner"
    creationComplete="creationCompleteHandler(event)"
>
</mx><mx :Script>
		< ![CDATA[
			import com.sheremetov.manager.tests.ConveyorTestSuite;
			import mx.events.FlexEvent;
 
			import org.flexunit.listeners.UIListener;
			import org.flexunit.runner.FlexUnitCore;
 
			private var flexUnitCore:FlexUnitCore;
 
			protected function creationCompleteHandler(event:FlexEvent):void {
 				flexUnitCore = new FlexUnitCore();
 				flexUnitCore.addListener( new UIListener( testRunner ));
 				flexUnitCore.run( ConveyorTestSuite );
 			}
 
		]]>
	</mx>
	<flexunituirunner :TestRunnerBase id="testRunner" width="100%" height="100%" />
< /mx:Application>
 

Обратите внимание на теги метаданных, которыми могут конфигурироваться классы TestSuite и TestCase. Вот полный список, поддерживаемых метатегов:

• [Suite] - указывает на класс Suite
• [Test] - указывает на метод теста, заменяет префикс test для метода. Поддерживает аттрибуты expected, async, order, timeout, ui
• [RunWith] - указывает на Runner с которым должен быть запущен TestSuite
• [Ignore] - Вместо комментирования метода теста достаточно указать этот метатег
• [Before] - заменяет setup() во FlexUnit и позволяет использовать несколько методов. Поддерживает аттрибуты: async, timeout, order, ui.
• [After] - заменяет teardown(), поддерживает: async, timeout, order and ui аттрибуты.
• [BeforeClass] - позволяет определить метод, вызываемый перед запуском класса теста, поддерживает аттрибут order
• [AfterClass] - помечает метод выполняемый, после запуска всех тестов в классе, поддерживает аттрибут order

Тест класса Task представляет из себя классический unit-test:

 
package com.sheremetov.manager.tests {
 
	import com.sheremetov.manager.Task;
	import flexunit.framework.TestCase;
 
	public class TaskTest extends TestCase {
 
		public function TaskTest(methodName:String=null) {
			super(methodName);
		}
 
		public function testNew(): void {
			var param:Object = {test:"passed"};
			var func:Function = testNew;
 
			var task: Task = new Task(func, 100, param);
 
			assertTrue(task.func == func);
			assertEquals(task.time, 100);
			assertEquals(task.params, param);			
 
			task = new Task(func, 100);
			assertNull(task.params);
			assertEquals(task.caller, this);
		}
	}
}
 

А вот класс для тестирования асинхронных вызовов выглядит интереснее:

 
package com.sheremetov.manager.tests {
 
	import com.sheremetov.manager.Conveyor;
	import com.sheremetov.manager.Task;
 
	import flash.events.Event;
	import flash.events.TimerEvent;
	import flash.utils.Timer;
 
	import org.flexunit.asserts.assertEquals;
	import org.flexunit.async.Async;
 
	public class ConveyorTest {
 
		private var conveyor: Conveyor;
		private var counter: int;		
 
		public function ConveyorTest() {
 
		}
 
		[Before]
		public function runBeforeEveryTest():void {
		    conveyor = new Conveyor();
		    counter = 0;
		}
 
		[After]
		public function runAfterEveryTest():void {
			conveyor = null;
		}       
 
		private function dummy(param: Object): void {
			counter++;
		}
 
		[Test(async,timeout="250")]
		public function testPlay():void {
			assertEquals(counter, 0);
			conveyor.add(new Task(dummy, 100, "one"));
 
			var timer1: Timer = new Timer(50, 1);
			timer1.addEventListener(TimerEvent.TIMER, Async.asyncHandler( this, onAfterFirst, 120));
			timer1.start();
 
			conveyor.add(new Task(dummy, 100, "two"));										
 
			var timer2: Timer = new Timer(150, 1);
			timer2.addEventListener(TimerEvent.TIMER, Async.asyncHandler( this, onAfterSecond, 220 ));
			timer2.start();
 
			conveyor.play();
		}
 
		private function onAfterSecond(event: Event, params: Object): void {
			assertEquals(counter, 2);
 
		}			
 
		private function onAfterFirst(event: Event, params: Object): void {
			assertEquals(counter, 1);
		}
 
	}
}
 

В этом классе вызовы типа Async.asyncHandler( this, onAfterFirst, 120) возвращают callback, этот вызов в случае если вызов не произойдет в течении 120 миллисекунд, сработает таймаут, и тест будет считаться проваленным.
Надеюсь код достаточно красноречив и понятен. А для тех кто захочет глубже разобраться с фреймворком, я рекомендую прочитать очень хорошую статью о использовании FlexUnit, неисчерпаемым источником информации являются 220 мегабайт кода репозитория проекта, вы легко можете экспотрировать его скачав svn, и сделав:

svn checkout http://opensource.adobe.com/svn/opensource/flexunit [путь-куда-вы-хотите-экспортировать]

The way to get started is to quit talking and begin doing. Walt Disney.

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

Как обычно, в таких разговорах участвуют «теоретики», строя свои теории на личном жизненном опыте, биографиях успешных людей, субъективном видении «проблемы». Итак, одна из вещей, которую я понял, в ходе нашего спора, это — отсутствие «четкой цели». Действительно, при более конкретном рассмотрении, зачастую выясняется что «первый миллион», целью не является, а скорее, люди просто «не против», чтобы он появился. Это очень четко видно по ответам на вопросы: «для чего» и «какие шаги были предприняты». В действительности, и я сам в этом убедился. Осознание того что что-то тебе жизненно необходимо, формирует весь мыслительный процесс, всё существование на достижении конкретной цели. Это известный факт как среди психологов, так и биоэнергетиков. Простой пример из жизни, — многие из моих знакомых «подумывают о машине», купить новую, сменить старую, - не важно. Важно, что в этом состоянии «уютного оцепенения» можно находится довольно долго. И напротив — те кто начинает активно искать «варианты», посещать салоны, «тест-драйвить» машины, находятся к покупке гораздо ближе. Причем это никак не связано с наличием или отсутствием денег, возможностью взять кредит и проч. Это связанно именно с осознанием «близости покупки», эти люди генерируют больше «активности» в этом направлении, с чем, собственно, и связана близость результата. О похожих взаимосвязях, говорится в нашумевшем американском фильме «Секрет». Только никакого секрета тут нет, — тот кто больше прикладывает усилий, и чьи усилия более сконцентрированы и целеустремленны, тот может рассчитывать на результат быстрее. Ведь просто?

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

Самое странное заключается в том что при всей очевидности и простоте этого алгоритма, по моим личным наблюдениям, следуют ему далеко не все, хотя те кто следуют — обязательно достигает результата.

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

Это классическая иллюстрация, описывающая пирамиду идей, на которых строится Семантическая паутина. Видно что в центре идеи находятся онтологии 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.

Итак, у истоков программирования стояли высокие мужи из академических кругов. Все эти фортраны, форты, самаллтолки, лиспы задали очень высокую планку для программистов. Разработка програм была делом нелегким, из-за несовершенства операционных систем, отсутствия общепринятых стандартов, многообразия платформ. Далее, — эпоха C. Еще дальше, когда количество кода в приложениях стало лавинообразно увеличиваться, а организовывать разработку команд программистов, стало гораздо сложнее, при том, что порог вхождения необходимо было уменьшать. Постепенно наступала эпоха ООП. Бизнес и конкуренция требовали многократного использования кода и высокой скорости разработки без ущерба качеству. Мало-помалу программные компоненты, библиотеки, модули стали играть очень важную роль, и постепенно особенности языка стали уходить на второй план. При плюс-минус аналогичном синтаксисе все популярные языки были очень похожи. Появились всевозможные средства визуального проектирования и программирования (VB, delphi, java, c#). Производители операционных систем, в свою очередь, пытаясь облегчить жизнь программистам, старались реализовать максимум функционала компонент на уровне системы, сделав софт «легче», «быстрее» и по возможности более жестко привязанным к платформе. С другой стороны, программисты, пытаясь облегчить процесс разработки, унифицировать его стали реализовывать всевозможные программные микроплатформы, фреймворки, скрывая за программными абстракциями всевозможные технологии, аппаратные и программные платформы, предоставляя программистам весьма высокий уровень абстракции и позволяя фокусироваться на конкретных бизнес-задачах.

Мы живем в очень интересное время. Похоже, производительность процессоров не будет расти так быстро, как это было на протяжении последних тридцати лет, и программистам придется решать проблемы производительности «ростом вширь». C другой стороны, обилие платформ и языков заставляет абстрагироваться программистов еще больше, в этом направлении появляется еще одно новое (или правильнее было бы сказать, хорошо забытое старое) веяние: dsl (domain specific language), специализированные языки разработанные для решения конкретных задач. Огромным преимуществом dsl, является максимальный фокус на предметной области решаемой задачи и максимально абстрактный подход, при том что конечная платформа зависит лишь от среды интерпретации. В связке с хорошим IDE этот подход позволит предоставить пользователям настолько простой язык, для решения их задач, насколько они сами того захотят (или ли же визуальную среду разработки), а программистам полную свободу по выполнению пользовательских сценариев. Надо сказать что написание dsl внутри языка было популярным уже в 60е годы, в среде программистов на лисп, но этот подход настолько опередил время, что не прижился в широких массах программистской среды и только сейчас набирает, как мне кажется, обороты. В принципе, уже сейчас, заметно сильное разделение между программистами «скриптописателями» и «платформостроителями», а со временем, по мере того как уровень среднего пользователя подрастет этот разрыв станет еще более очевидным.

Как бы то ни было, уверен, мы еще застанем и увидим эти перемены.

 
<report>
  <scripts>
    <script name="...\framework.swc(mx/core/EventPriority)" mod="1201055703673" size="755" optimizedsize="400">
      <def id="mx.core:EventPriority" />
<pre id="Object" />
      <dep id="mx.core:mx_internal" />
      <dep id="AS3" />
    </script>
    <script name="_plainStyle.as" mod="9223372036854775807" size="798" optimizedsize="640">
      <def id="_plainStyle" />
<pre id="Object" />
      <dep id="mx.core:IFlexModuleFactory" />
      <dep id="mx.styles:StyleManager" />
      <dep id="AS3" />
      <dep id="mx.styles:CSSStyleDeclaration" />
    </script>
</scripts></report>

Анализировать его не очень то и просто. Гугл подсказал несколько вариантов разбора этого XML:

1. При помощи XSLT
2. С помощью небольшого приложения

Я предлагаю альтернативный и наглядный способ анализа, при помощи excel:

• Первое что надо сделать, — это добавить первой строкой «< ?xml version="1.0" encoding="UTF-8" ?>»
• Открываем XML
• Выбираем в диалоге «As an XML table». Имеем все данные в таблице.
• Имело бы смысл сгруппировать модули и посмотреть суммарный размер каждого.
• Выделяем интересующие нас данные.
• Нажимаем Insert — Pivot Table (сводная тадлица).
• В появившемся окне кликаем чекбокс возле name и перетяиваем optimizedsize в Values. В Value Field Settings меняем функцию с Count (сейчас показывает количество группировок для каждого модуля) на Sum
• Сортируем по убыванию размера модулей.

Должно получится что-то типа такого: