Я не знаю что здесь и написать

А мы переехали, да

2011-03-03T01:46:00.000-08:00

Программисты не умеют программировать

2011-01-16T06:18:00.000-08:00

Недавно вновь прогремела статья из блога "Coding Horror" "Why Can't Programmers.. Program?".
Суть статьи заключается в мысли, что среднестатистический программист не способен решить простую задачу(реализация задачи "FizzBuzz", см. далее) менее чем за 10 минут(10-15, как сказано в статье).
Ещё в 2007ом данный вопрос взбудоражил всех и вся. Все начали доказывать что автор - идиот и "АПАЗОРИЛСЯ". Однако, людям удалось доказать не только это, но и то, что программисты не умеют программировать.

Для начала, вот задача "FizzBuzz":

Write a program that prints the numbers from 1 to 100. But for multiples of three print "Fizz" instead of the number and for the multiples of five print "Buzz". For numbers which are multiples of both three and five print "FizzBuzz".

А вот и перевод:

Напишите программу, которая выводит на экран числа от 1 до 100. При этом вместо чисел, кратных трем, программа должна выводить слово «Fizz», а вместо чисел, кратных пяти — слово «Buzz». Если число кратно и 3, и 5, то программа должна выводить слово «FizzBuzz».

via LOR
Нужно отметить что задача очень проста, а главное - описана прямо, нет нужды самому что-то додумывать, составлять ТЗ.

Для начала, стоит поговорить о том, сколько времени займёт реализация задачи средним программистом. А действительно, сколько?
Многие люди трактуют утверждение как "ты лох, не сможешь решить задачу так быстро". Это не так. Это бред. Ты себя считаешь среднестатистическим программистом?

Если да, то у меня для тебя плохие новости: среднестатистический программист кодит на пхп и не знает что такое MVC. На западе, конечно, ситуация похожа, но значительно лучше: там(в образе среднестатистического программиста) есть и джавакодеры, и рубисты. Эти программисты могли получить овер9к 5ок в школе, получить по 10 В/О, поучаствовать в 100500 проектах(среди которых могут быть крупные), заслужить уважение у многих людей, получить награды, дипломы, сертификаты etc. Среди таких программистов есть и хорошие люди, среди них есть даже умные, но которым просто нет нужды дальше развиваться, а сами они и не хотят.
Самое важное то, что такие программисты решают определённые задачи, но если ты попросишь что-то иное, что они никогда не делали, то им придётся подумать. 10-15 минут.
А теперь ПОДУМАЙ! Такой ли ты программист? Если ты читаешь эту статью, то велик шанс что ты значительно выше.

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

Вообще, конечно, статья на "кодинг хоррор" не говорит о том, что именно эту задачу средний программист реализует именно за 10-15 минут. Это только пример, это только цифры из головы.
НЕ БУДЬТЕ ИДИОТАМИ!
Умейте улавливать мысль. Умейте понимать мысль. Умейте читать между строк. Не придирайтесь к таким мелочам, которые не играют роли. Это слова, никому не нравится, когда люди придираются к словам, не улавливая сути! Это бесит, выводит автора из себя.
Я это хорошо испытал на себе и не пожелаю таких вещей даже врагу.

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

Всё.
Если вы увидели что-то другое, оскорбляющее вас, автора статьи или что-то ещё, то вам нужно хорошенько подумать или просто лечиться.

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

В качестве источников будут использоваться 3 статьи:
На ЛОРе
На Хабре
Оригинальная статья на Coding Horrors

Первый алгоритм

Visual Basic Script:

Dim i

For i = 1 to 100
 If (i Mod 3 = 0) And (i Mod 5 = 0) Then
  WScript.Echo "FizzBuzz"
 ElseIf (i Mod 3 = 0) Then
  WScript.Echo "Fizz"
 ElseIf (i Mod 5 = 0) Then
  WScript.Echo "Buzz"
 Else
  Wscript.Echo i
 End If
Next

Как можно судить по языку, на котором написан этот код, автор являлся начинающим программистом. Стоит отметить, что сам VBS является таким языком, на котором программируют либо начинающие, либо любители MS Office, а сам язык не обладает таким уж количеством инструментов, из-за чего приходится часто заниматься такими вот задачами.
Решение не хитрое. Прямое, но хорошо выполняющее задачу. Это один из правильных вариантов.

Мой код(написание - меньше минуты), в лоб:

for i in xrange(1, 101):
   if (i % 3) == 0 and (i % 5) == 0:
      print "FizzBuzz"
   elif (i % 3) == 0:
      print "Fizz"
   elif (i % 5) == 0:
      print "Buzz"
   else:
      print i

Надо сказать что такой алгоритм почти никто не предоставлял, но почти все очень похожи.

Второй алгоритм

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

for i in range(1,101):
    s = ''
    if (i % 3 == 0):
        s += 'Fizz'
    if (i % 5 == 0):
        s += 'Buzz'
    if not s:
        s += str(i)
    print s

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

А вот дальше идут более интересные примеры.

Руби. Первый алгоритм.

1.upto(100) { |n| puts n % 3 == 0 ? n % 5 == 0 ? "fizzbuzz" : "buzz" : n % 5 == 0 ? "fizz" : n }

Стоит отметить что выполняя простую задачу, все стремятся выполнить её в одну строчку или просто как можно более компактно. Не думайте о объёме кода, думайте о алгоритме! Отбросьте лямбды, замыкания, оптимизацию, инструменты. Думайте не инструментами, а просто логикой!
Сокращая код, реализующий плохой алгоритм, вы сокращаете буквы, когда можно слова!
Вот два похожих примера:

for i in ("FizzBuzz" if not x % 15 else "Fizz" if not x % 3 else "Buzz" if not x % 5 else x for x in xrange(1,101)): print i

map( print, ( "FizzBuzz" if not x % 15 else "Fizz" if not x % 3 else "Buzz" if not x % 5 else x for x in xrange(1,101)) )

Заметьте математическую оптимизацию в виде замены двойного условия на одно:

if not x % 15

Интересный вариант, но не имеет права на жизнь.

for i in range(1,101): print {0:"FizzBuzz", 3:"Fizz", 6:"Fizz", 9:"Fizz", 12:"Fizz" , 5:"Buzz", 10:"Buzz"}.get(i%15, i)

Вообще, однострочников действительно туча среди вариантов. Все они делятся на 3 категории: первый, второй алгоритм и один или другой но через ж.

Вот здесь такая подборочка.

Всё это адов страх и ужас. Более всего пугает тот факт, что люди часто пишут такой код с самого начала, так и понимая задачу. Они тратят кучу времени на этот код, но в результате получают говно, которое не только трудно читать, теряет алгоритм в коде, не даёт понять задачу, но ещё и оказывается затратнее прямого варианта. Зачем?

Более всего интересен тот факт, что многие просто не могут понять задачу, упускают какие-либо моменты, трактуют свои правила.

for (int i = 1; i 101; i++)
{
 if ((i % 3) == 0) Console.Write("Fizz");
 if ((i % 5) == 0) Console.Write("Buzz");
 Console.WriteLine();
}

for num in range(1, 101):
 if not num % 3:
  print "bizz"
 elif not num % 5:
  print "buzz"
 else:
  print num

#CF (SCRIPT) version
for (i = 1; i LTE 100; i = i + 1) {
if ((j MOD 3) AND (j MOD 5)) {
WriteOutput(i);
} else {
if (NOT j MOD 3) {WriteOutput('FIZZ');} 
if (NOT j MOD 5) {WriteOutput('BUZZ');}
}
WriteOutput(chr(13) chr(10));
}

for (int i = 0; i < 100; i++) {
 bool byThree = (!(i % 3));
 bool byFive = (!(i % 6));
 if (byThree) std::cout << "Fizz";
 if (byFive) std::cout << "Buzz";
 if (!byThree && !byFive) std::cout << i;
 std::cout << std::endl;
}

#include 
#include 
int main(int argc, char * argv[])
{
   int i = 0;
   for (i = 0; i < 100; i++) {
      if (i%3 == 0)
         printf("Fizz\n");
      else if (i%5 == 0)
         printf("Buzz\n");
      else if (i%3 == 0 && i%5 == 0)
         printf("FizzBuzz\n");
      else
         printf("%d\n", i);
   }
   return EXIT_SUCCESS;
}

Etc. Много разного кода, который по невнимательности написан таким, что не может выполнять задачу правильно. А про то, что люди забывают использовать для сравнения <= вместо <, при этом используют число 100, в результате чего выполняется цикл до 99, а не 100... В последнем сырце никогда не будет напечатано FizzBuzz. Почему? Подумайте. Ответ прост.

Очень много кода, который был написан не в шутку, но просто получилась грязь. Хотя, некоторые сырцы заслуживают внимания.

(defun fizzbuzz (n)
(when ( n 0) 
(fizzbuzz (- n 1))
(format t "~a~%" 
(if (= (mod n 3) 0)
(if (= (mod n 5) 0) "FizzBuzz" "Fizz")
(if (= (mod n 5) 0) "Buzz" n)))))
(progn (fizzbuzz 100) (values))

def fizzbuzz(n):
 if n:
 if n % 15 == 0: return fizzbuzz(n-1) + 'fizzbuzz ';
 elif n % 5 == 0: return fizzbuzz(n-1) + 'buzz ';
 elif n % 3 == 0: return fizzbuzz(n-1) + 'fizz ';
 else : return fizzbuzz(n-1) + ('%d ' % n)
 return ''
fizzbuzz(100)

for (x=1;x101;x++)
{
sprintf(temp,"%s",x%3 ? "":"fizz");
sprintf(tem1,"%s",x%5 ? "":"buzz");
strcat(temp,tem1);
if (!temp[0])
sprintf(temp,"%d",x);
printf("%s\n",temp);
}

#include 
int main(int argc, char *argv[argc])
{
   {
   char const *output[] = {"%d\n", "Fizz\n", "Buzz\n", "FizzBuzz\n"};
   for(size_t i = 1, check = 0; i <= 100; ++i, check = 0)
   {
      if(0 == i%3)check |=1;
      if(0 == i%5)check |=2;
      printf(output[check], i);
   }
   }
   return getch();
}

toString :: Int -> String
toString n | n `mod` 15 == 0 = "FizzBuzz"
           | n `mod`  3 == 0 = "Fizz"
           | n `mod`  5 == 0 = "Buzz"
           | True            = show n
solve :: [Int] -> IO ()
solve [] = return ()
solve (x:xs) = do putStrLn (toString x)
                  solve xs
main :: IO ()
main = solve [1 .. 100]

program main
    character*8 str
do i=1,100
   write(str(1:8),'(i8.1)') i
   If (mod(i,3).eq.0) then
      write(str(1:8),'(A8)') "Fizz    "
   endif
   If (mod(i,5).eq.0) then
      write(str(1:8),'(A8)') "Buzz    "
   endif
   If (mod(i,15).eq.0) then
      write(str(1:8),'(A8)') "FizzBuzz"
   endif
   write(*,*) str
enddo

100.times do |i|
  num=i+1
  [ (num % 3).zero? ? "Fizz" : nil,
    (num % 5).zero? ? "Buzz" : nil,
    ((num % 3).zero? or (num % 5).zero?) ? nil : num,
    ","
    ].compact.join.display  
end

% 2min
-module(fizzbuzz).
-compile(export_all).
f(N) when (N rem 15) == 0 -> io:format("FizzBuzz~n", []), f(N+1);
f(N) when (N rem 5) == 0 -> io:format("Buzz~n", []), f(N+1);
f(N) when (N rem 3) == 0 -> io:format("Fizz~n", []), f(N+1);
f(101) -> ok;
f(N) -> io:format("~p~n", [N]), f(N+1).
start() -> f(1).

let divs = [(3, "Fizz"); (5, "Buzz")]
let prefix i = 
    divs 
    |> Seq.filter (fun (d, _) -> (i % d) = 0) 
    |> Seq.map snd 
    |> String.concat ""
let convert i = 
    let special = prefix i
    if special = "" then
        string i
    else
        special
{1..100} 
|> Seq.map convert 
|> Seq.iter (fun x -> printfn "%A" x)

Etc. Да, мне страшно за умных людей. Я не просто так говорю что на ЛОРе, например, сидят профессионалы. Большинство реально профессионалы своего дела(тем более в сравнении с "среднестатистическим программистом"). Увы, мало кто способен выбирать верный путь, инструмент. Это жуть как пугает.

Часто люди становятся рабами плохих технологий. Среди них есть и авторы предыдущих сырцов. Это очень, очень обидно.

#php
for($i=0;$i++<100;)
{
$f=$i%3?'':'Fizz';
$b=$i%5?'':'Buzz';
echo$f.$b?$f.$b:$i,',';
}

(loop for i from 1 to 100 do
  (print (cond ((zerop (mod i (* 3 5))) "FizzBuzz")
               ((zerop (mod i 3)) "Fizz")
               ((zerop (mod i 5)) "Buzz")
          (t i))))

for (1..100) {
        my $t = '';
        $t = 'Fizz' unless $_ % 3;
        $t .= 'Buzz' unless $_ % 5;
        $t ||= $_;
        print "$t\n";
}

Процедура ПриНачалеРаботыСистемы()
  Для Сч = 1 По 100 Цикл
    Если Сч % 15 = 0 Тогда
      Сообщить("FizzBuzz")
    ИначеЕсли Сч % 3 = 0 Тогда
      Сообщить("Fizz")
    ИначеЕсли Сч % 3 = 0 Тогда
      Сообщить("Buzz")
    Иначе
      Сообщить(Сч)
    КонецЕсли;
 КонецЦикла;
КонецПроцедуры


Console.WriteLine(
                string.Join(
                    Environment.NewLine,
                    Enumerable.Range(1, 100)
                        .Select(num =>
                            num % 5 == 0 && num % 3 == 0 ? "FizzBuzz" :
                            num % 3 == 0 ? "Fizz" :
                            num % 5 == 0 ? "Buzz" :
                            Convert.ToString(num)
                        )
                )
 );

#SWI-Prolog
fizzBuzz(100).
fizzBuzz(N) :-
 I3 is N mod 3,
 I5 is N mod 5,
 print( I3, I5, N ), nl,
 N2 is N + 1,
 fizzBuzz(N2).
print( 0, 0, _ ) :-
 write( 'FizzBuzz' ).
print( 0, _, _ ) :-
 write( 'Fizz' ).
print( _, 0, _ ) :-
 write( 'Buzz' ).
print( _, _, N ) :-
 write(N).

#gprolog
fizzlist(0, [], M).
fizzlist(N, [H|T], M) :- N > 0, N1 is N - 1, M1 is M - N + 1, fizzbuzz(M1, H), fizzlist(N1, T, M).
fizzlist(N, L) :- fizzlist(N, L, N).
fizzbuzz(N, N) :- N mod 3 > 0, N mod 5 > 0.
fizzbuzz(N, 'Fizz') :- 0 is N mod 3, N mod 5 > 0.
fizzbuzz(N, 'Buzz') :- 0 is N mod 5, N mod 3 > 0.
fizzbuzz(N, 'FizzBuzz') :- 0 is N mod 3, 0 is N mod 5.

#mercury
:- module fizzbuzz.
:- interface.
:- import_module io.
:- pred main(io, io).
:- mode main(di, uo) is det.
:- implementation.
:- import_module int.
main --> fizzbuzz(1).
fizzbuzz(N) --> 
 ( {N =< 100} ->
  print_fizzbuzz(N),
  print(" "),
  fizzbuzz(N + 1)
 ; []
 ).
print_fizzbuzz(N) --> 
 ( {N mod 3 = 0} ->
  ( {N mod 5 = 0} ->
   print("fizzbuzz")
  ; print("fizz")
  )
 ; {N mod 5 = 0} ->
  print("buzz")
 ; print(N)
 ).

Etc. А ещё есть много любителей преждевременной оптимизации.

#include 
int main()
{
   int i;
   for (i=1;i<=100;i++){
      if (!(i % 3)){
         if (!(i % 5)) printf("Fizzbuzz\n");
         else printf("Fizz\n");
      } else if (!(i % 5)) printf("Buzz\n");
      else printf("%d\n",i);
   }
   return 0
}

for ($i = 1; $i <= 30; $i++)
{
    if (($i % 3 != 0) AND ($i % 5 != 0)) echo $i;
    else
    {
        if ($i % 3 == 0) echo 'Fizz';
        if ($i % 5 == 0) echo 'Buzz';
    }
    echo '
';
}

for i := 1 to 100 do
if i mod 3 = 0 then
if i mod 5 <> 0 then
print('Fizz')
else
print('FizzBuzz')
else
if i mod 5 <> 0 then
print(i)
else
print('Buzz');

Etc. Здесь даже нечего добавить.

А ещё есть огромное число либо новичков, либо не опытных кодеров. Много кода, который использовал дополнительные переменные, флаги, иной бред.

bool printint;
for (int i = 1; i = 100; i++)
{
printint = true;
if (i % 3 == 0) { Console.Write("Fizz"); printint = false; }
if (i % 5 == 0) { Console.Write("Buzz"); printint = false; }
if (printint) Console.Write(i.ToString());
Console.WriteLine();
}

public class FizzBuzz
{
public static void main(String [] args)
{
int k;
for(int i=1; i=100; i++)
{
k = 0;
if(i%3==0)
{
k = 1;
}
if(i%5==0)
{
k = k + 2;
}
switch(k)
{
case 1:
System.out.println("Fizz");
break;
case 2:
System.out.println("Buzz");
break;
case 3:
System.out.println("FizzBuzz");
break;
default:
System.out.println(i);
}
}
}
}

#include stdio.h
int main(void)
{
int i,j=0;
for(i=0;i=100;i++)
{
if((i%3)==0)
{
printf("Fizz");
j=1;
}
if((i%5)==0)
{
printf("Buzz");
j=1;
}
if(!j)
{
printf("%d",i);
}
printf("\n");
j=0;
}
}

#include 
int main() {
  for (int i=1; i<=100; i++) {
    int a=i%3, b=i%5;
    if (a)
      if (b) printf("%d\n");
      else printf("Buzz\n");
    else
      if (b) printf("Fizz\n");
      else printf("FizzBuzz\n");
  }
}

Но все учились, это нормально. Стоит отметить что даже такие люди генерили решение в пределах 10 минут.

И в заключение надо бы выделить несколько красивых решений обычных алгоритмов. Все они зависят от языков, это язык даёт им такую красоту.

1.upto(100) do |i|
out = nil
out = out.to_s + 'Fizz' if i % 3 == 0
out = out.to_s + 'Buzz' if i % 5 == 0
puts out || i
end

#lua is nice!
for i=1,100 do 
fizz= (i%3==0) and "Fizz" or ""
buzz= (i%5==0) and "Buzz" or ""
print(i,fizz..buzz)
end

for (var i = 1; i <= 100; i ++) {
var x = '';
if (i % 3 == 0) x += 'Fizz';
if (i % 5 == 0) x += 'Buzz';
console.log(x || i);
}

В первом коде интересна идея применения "или" для определения что нужно напечатать: цифру или слово.
Во втором(луа) офигенна идея слияния строк.
В третьем используется такая же идея, как и в первом.

Заключение

Это ужас, ребята. Из всего кода, который был представлен людьми, около 2% является кодом, который можно понять только взглянув на него.
Очень, очень много кода, который написан используя ужасный стиль. Ужасный! Так нельзя.
Хорошо было показано то, что люди редко выбирают нужны инструмент для нужной задачи. Люди становятся рабами своих инструментов и просто не хотят верить что есть что-то лучше.
Программисты выбирают красоту семантики, вместо красоты синтаксиса.
Используют преждевременную оптимизацию, затягивая реализацию решения.
Используют ресурсы не думая о них.
Думают "в лоб".

В итоге, я точно могу сказать что, на собеседовании у меня, около 80% авторов кода просто отпали бы. Ещё 15% я бы сохранил в списке, но при появлении хоть одного из оставшихся 5%, я бы их всех отсеял или просто оставил для будущего.
Больше всего пугает тот факт, что среди авторов кода только около 3% людей являются представителями более или менее близкого к среднестатистическому программисту уровня.

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

Python. Хочу DSL.

2011-01-13T13:18:00.000-08:00

Многие рубисты, джависты, лиспофанаты etc очень любят говорить о DSL.
Что такое DSL? Почитайте в википедии, гугле или ещё где. Если говорить коротко, то это специфичные для определённой задачи языки, которые отбрасывают сложности в описании и решении задачи.

create page
   name 'Hey'
   date 11-01-2011
   text 'How about new DSL?'

Не правда ли красиво? Ну это всяко красивее аналога на чистом питоне. Похоже на yaml, но одного yaml'а здесь явно не хватит, нужна поддержка функций, интерпретация, более глубокая семантика. На руби такой код составить будет не сложно. Это практически валидный руби-код.
Конечно, на руби точно такой код не получить. Добавится end, дату нужно будет иначе описывать...

На питоне это можно оформить так:

p = Page()
p.name = 'Hey'
p.date = '11-01-2011' или datetime.datetime.from....
p.text = 'How about new DSL?'

Ужас, не так ли? Голая логика, строгость и КОДИНГ. Можно и иначе, с помощью with. Однако, нужно будет описывать __enter__, __exit__, что заставит наш код быть ориентированным на работу с этим оператором, что излишне.

Увы, на питоне нет средств для написания DSL. Или есть?

Прежде всего, DSL бывают разные. Внутренние(internal) и внешние(external). Оба типа DSL являются относительными.

Грубо говоря, внутренние - сделанные средствами самого языка, используемые внутри самого языка. Типичные DSL на руби и лиспе(я промолчу на счёт джавы, ибо не изучал этот вопрос на ней) являются внутренними DSL, которые строятся через дополнение синтаксиса средствами самого языка. Фактически, в лиспе это не является дополнением синтаксиса, как и в руби. Просто добавление ключевых слов, функций, логики... Словом, просто пляски вокруг синтаксиса, используя возможности самого же языка. Язык сильно ограничивает возможности по создания внутреннего DSL.
Примерами внутренних DSL являются десятки DSL для Ruby on Rails, огромное число пакетов тестирования для руби, питона, HAML, SASS, CleverCSS, десятки диалектов лиспа etc.
В наше время каждый современный программист использовал DSL или хоть пробовал данную идею.

Внешние DSL - язык, созданный "в лоб". Для него делается свой интерпретатор/компилятор, синтаксический парсер etc. К таким языкам часто относятся языки темплейтов в веб-фреймворках. По сути, это изобретения велосипеда. Mako(язык темплейтов, так популярный в веб-фреймворке Pylons), например, является транслятором в Python. Да-да, код транслируется в код на питоне(а точнее, в один модуль с одной функцией).

Чаще всего выходит так, что для одной цели, где нужен внутренний DSL, задача решается "в лоб" из-за незнания или иных проблем. Это приводит к созданию нового языка со своими конструкциями. Не редко язык получается уродливым, да и задача решается не так как хотелось бы. Ладно если язык компилируемый, но если он интерпретируемый, то это создаёт оверхед(во всех аспектах программирования) такого размера, что выть хочется.

Ладно, давайте ближе к делу, а именно, к DSL на Python.

В Питоне нет функционала для создания DSL. Гвидо официально пофиг(ищите списки рассылок, вопрос поднимался много раз, но темы всегда заминали). Более того, язык перестал развиваться. Однако, он всё ещё является лучшим языком, с явно бОльшим будущем чем у руби. Почему? Py3k с каждым релизом становится всё быстрее и быстрее. Хотя хватит рекламы. CPython 3 всё-равно говно, но лучше нет.
У Питона пока 2 проблемы:
1) Замороженный синтаксис(да, он просто уже не развивается).
Более того, в тройке он деградировал(вроде отсутствия "%").
2) Плохая реализация(да, она просто говно).
Все надежды на PyPy, Unladen Swallow, но первый пилят уже слишком долго, а второй хотят прикрыть, т.к. не подходит для гугла.

А ещё есть джава. А ещё есть эрланг. А ещё есть лисп.
Но есть только один достаточно хороший для 2010ого(а уже 2011ый!) года - Python.

Ладно, это уже может пахнуть фанатизмом, нам нужен DSL! Мы хотим сделать Python совершенным, а для этого нужно просто получить возможность делать DSL, сделать блоки кода объектами, убрать подчёркивания в некоторых методах, сделать приватные члены не через подчёркивание...

Гугл сразу даёт массу ссылок на инструменты по созданию external DSL: PyParsing, Ply, PySEG, Pysec... Их действительно много.
Если бы я делал свой язык, то я бы использовал что-то из этого списка, но для DSL это всё не может подходить(не для таких DSL, которые нам нужны).

А что нам нужно?
Добавить пару своих операторов, обрабатывающих операнды через нашу логику.
Добавить пару спец. символов.
Немного изменить логику работы со стандартными типами(обернуть строки в наш специальный класс, например).
Получить возможность как можно более простого описания DSL, который будет справляться с такими задачами.
etc.

Чего мы не хотим?
Писать свой язык.
Копаться в кишках чего-то.
Изучать лексеры.
Превышать среднюю концентрацию символов "_" более чем на 2 символа на 3 строчки кода(шутка, хоть и есть доля правды).
Создавать оверхед, рантаймовый препроцессор или что-то в этом духе.
etc.

А сейчас важная деталь, которая необходима для понимания смысла DSL, что это такое, зачем это всё: Питон это ТОЖЕ DSL; любое небольшое вмешательство позволяет говорить что ты сделал свой DSL.
Почитайте вот это письмо из рассылки, в котором есть информация о том, как в питоне "реализованы" DSL.
В письме есть ссылка на "DSL для графов".
На самом деле там нет ни слова о DSL, но указывается на удобство Питона для таких задач.
А ещё там замечательная ссылка на туториал с пикона. Но, как и все туториалы с пикона, демонстрации, показы, презентации etc, их можно увидеть только один раз. Передаю струйку рака в сторону кодеров, которые не заботятся о том, чтобы их презентации были выложены в сеть.

Ладно, хватит о мелочах, о частностях. У нас есть цель, задача, а самое главное - вот такой вот интересный Я, который покажет вам что можно юзать для таких задач.

К слову, есть мнение, что DSL делается безумно просто и на Питоне, ровно как и на Руби. Однако, нет примеров, но есть такие слова как "Zope", "Django", "TG2". Да, в них есть DSL'и, но они относятся к мелким добавкам к основному языку. Ничего интересного.

Ладно, я слишком много рассуждал, тянул время, заставлял ждать. Думаю, вы готовы.

http://fmeyer.org/en/writing-a-DSL-with-python.html

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

Для начала, вот живой код, который должен, будет работать:

# coding: pyspec
class Bow:
    def shot(self):
        print "got shot"

    def score(self):
        return 5

describe Bowling:
    it "should score 0 for gutter game":
        bowling = Bow()
        bowling.shot()
        assert that bowling.score.should_be(5)

А теперь небольшое отступление.
Помните что нужно делать, чтобы код на питоне воспринимался как utf8? Так вот, это не магия, это большая система, которая хорошо продумана. Называется она "кодеки".
Благодаря наличию такой системы, мы можем получить доступ к ТОКЕНАЙЗЕРУ Питона, к ридеру кода! Мы можем управлять тем, как код понимается компилятором в pyc и интерпретатором! Да-да!

Обратите внимание на первую строчку кода. Мы указываем что хотим использовать несуществующий кодек - кодек, который мы напишем. Именно этот кодек позволит обрабатывать нестандартные операторы, изменять логику работы.

Весь код реализации можно смотреть по ссылке выше, нам же интересно то, что мы будем писать сами и понять как это всё работает.

Структура кодека содержит поля: name, encode, decode, incrementalencoder, incrementaldecoder, streamreader, streamwriter. Нам важно только одно - переписать streamreader чтобы можно было задействовать свои хуки.
Собственно, все действия сводятся к созданию хендлера для поиска кодека, в котором мы возвращаем наш новый кодек, если имя совпадает. Кодек создаём передавая все поля как у utf8-кодека, но вот streamreader мы делаем свой.

import tokenize
import codecs, cStringIO, encodings
from encodings import utf_8

class StreamReader(utf_8.StreamReader):
        def __init__(self, *args, **kwargs):
            codecs.StreamReader.__init__(self, *args, **kwargs)
            data = tokenize.untokenize(translate(self.stream.readline))
            self.stream = cStringIO.StringIO(data)

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

поток из файла -> (токенайзер -> наш транслятор) -> валидные питонотокены -> интерпретатор/компилятор

Вот как будет выглядеть наш "транслятор":

def method_for_it(token):
    return token.strip().replace(" ", "_").replace("\"","" ) + "(self)"
 
def translate(readline):
    previous_name = ""
    for type, name,_,_,_ in tokenize.generate_tokens(readline):
        if type ==tokenize.NAME and name =='describe':
            yield tokenize.NAME, 'class'
        elif type ==tokenize.NAME and name =='it':
            yield tokenize.NAME, 'def'
        elif type == 3 and previous_name == 'it':
            yield 3, method_for_it(name)
        else:
            yield type,name
        previous_name = name

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

А теперь давайте посмотрим на pros/cons этого метода.
+ Возможность написания внутренних DSL.
+ Возможность изменять готовое, а не писать с нуля.
+ Возможность использовать всё тот же питон.
+ Отсутствие необходимости писать всё и вся с нуля.
+ Использование родного, встроенного в Пайтон функционала.
+/- Гибкость. Не самый гибкий метод, но позволяет делать многие вещи, которые нельзя в руби.
- Работа по принципу "read&replace". Мы работаем со строками!
- Слабый дебаг. Велика вероятность что если будет ошибка, то её сложно будет найти, т.к. питон будет выкидывать пост-парсинговый код, а не код на DSL.
- Сложность описания DSL.
- Необходимость описания небольшой, более удобной обёртки.
- ЭТО КОСТЫЛЬ! Кодеки не для этого предназначены.

В любом случае, лучше варианта нет, а если использовать активно и пропагандировать, то можно будет надеяться что Гвидо прогнётся под коммьюнити и даст нам хороший инструмент.

В заключение хочется вбросить одну ссылку на интересную мысль на счёт DSL на Пайтоне, а точнее на применение DSL для ORM на Пайтоне.
http://blog.ianbicking.org/more-on-python-metaprogramming.html

Python, Ruby. Официальная™ точка зрения Iorlas'а.

2010-12-29T17:14:00.000-08:00

К данному посту побудил тред на лоре:
http://www.linux.org.ru/forum/development/5735572

Так много текста написал и не хочется чтобы он пропадал.

Сейчас вокруг Пайтона сложились 2 основных стереотипа:
1) Самый тормозной язык на свете
2) Джанго - хороший веб-фреймворк

Мнение о производительности пайтона сложилось из таких проектов как Gajim, Rhytmbox, Banshi(или какие там ещё есть поделки). Опыт данных поделий показывает, что пайтон(как и любой высокоуровневый язык) плохо подходит для написания ресурсоёмкой и требовательной к производительности логики(писать приложение на сложной высокопроизводительной сетевой библиотеке - да, писать сложную высокопроизводительную сетевую библиотеку - нет(намёк на твистед, который написан на Си как модуль для пайтона, но используется для приложений на пайтоне)).
Однако, стоит заметить, что даже лёгкую логику, используя Си, можно написать так, что оно будет работать очень медленно(transmission).
Вывод: на пайтоне нужно уметь писать, а не слепо использовать технологию.

Джанго - самый развитый веб-фреймворк на пайтоне, имеющий самую большую публику среди веб-фреймворков на пайтоне же. Просто он самый простой из веб-фреймворков на питоне и, как говорят некоторые люди, стремится быть аналогом RoR(что совсем не так, а даже если бы и было так, то получается оно отвратно, совсем не получается). Джанго тормозит, страдает неоднозначностью(что ласково называется "возможностью выполнить одну вещь многими путями", но это не RoR, здесь это неудачно, очень неудачно), имеет много костылей, неудачные реализации простых вещей и ORM, который хоть и работает быстрее SQLAlchemy, но является страшным гогном.

Какое истинное лицо Python?
В первую очередь, это язык для создания скриптов, десктопных приложений, микро веб-приложений, больших (веб)приложений, требовательных к производительности.
Скрипты - понятно, очень удобно, большая стандартная библиотека, куча возможностей, простой и понятный синтаксис.
Десктопные приложения. Поскольку написание приложений используя GTK, Qt etc на пайтоне - очень простое дело, есть куча биндингов к либам, возможность простого написания логики на Си и использования её на более высоком уровне на питоне, питон является очень хорошим языком для такой цели.
Микро веб-приложения это приложения, в которых нет нужды в большой логике, где нужно чтобы всё работало искаропки или просто не требовало таскать за собой кучу файлов для небольшого приложения. Самый популярный пример - WebPy. Много кто его использует, есть даже люди, которые используют его для сложной логики, что является бредом и фанатизмом. Идеальный пример микро веб-приложения - веб-гуй для rtorrent(увы, никому нет дела, но решение было бы хорошим, лучше чем на пехапе).
Большие (веб)приложения. За счёт того, что узкие места можно написать на Си, а управлять ими на Пайтоне, можно использовать данный язык для крупных приложений, используя высокоуровневый язык для высокого уровня проекта. Это позволило родиться таким веб-фреймворкам как Werkzeug, Pylons, Pyramid etc. Они достаточно просты, динамичны, имеют простую внутреннюю логику, позволяют делать что хочется с любой частью веб-приложения. К таким фреймворкам относятся и Twisted, и Tornado.

Для средних и небольших проектов использовать пайтон слишком сложно и просто не окупается. Проще использовать руби и рельсы.

Я сам использую и руби, и пайтон, и си. У меня есть опыт в использовании и джанго, и рельс, и пайлонс, и пирамид, и твистед, и даже немного PHP с симвонией, зендом, друпалом. Я хорошо взвесил все за и против, хорошо исследовал враждующие технологии и сделал выводы(они описаны выше). Я не защищаю инструменты, я просто говорю какие выводы сделал я, я просто говорю что они совпадают со мнениями опытных программистов, я просто делюсь точкой зрения. Хочешь - прими её, хочешь - нет.
Забавно будет посмотреть на тех, кто сможет назвать меня троллем или фанатиком, поскольку я не использую то, что мне же хуже, а значит я выбираю как можно более подходящие инструменты для своих задач.

RubyMine, PyCharm и всё что построено на IDEA/Swing. Некролог.

2010-12-29T06:33:00.000-08:00

Несколько раз я пробовал это чудо. Надо сказать что по функционалу это фантастика, везде хвалят, любят, пользуют(хотя из знакомых есть всего 2 любителя IDEA, и те юзают PyCharm).
Цель сегодняшней попытки - добить это дело, довести RubyMine до "совершенства" и определить можно ли его использовать.

В первые свои попытки завести PyCharm и RubyMine, я столкнулся с проблемой рендерринга окон IDEA. Это было просто серое окно:

Гуглить по признакам было не легко, но в конце концов я дошёл до нужной ссылки:
https://awesome.naquadah.org/wiki/Problems_with_Java

Суть в чём: Awesome является одним из менеджеров окон, который не поддерживает re-parenting. Обидно, но не очень.

К слову, данная проблема не подтверждена на Java 1.7. Я использую Java HotSpot 64-Bit Server VM 1.6, где данная проблема широко известна.

Официально это считается багом, но Sun так и не удосужились пофиксить его(хотя, по ссылкам на багрепорты есть отчёты за 2008ой год, что фиксы есть и они применены, но хз).
Поэтому вендорам дистрибутивов пришлось самим вставлять патчи, которые активируются при добавлении ключа для JVM:

_JAVA_AWT_WM_NONREPARENTING=1; export _JAVA_AWT_WM_NONREPARENTING

Увы, не везде данный патч есть, поэтому есть иной вариант.
Дело в том, что Sun сами попали в свои грабли. Как? Очень просто. Дело в том, что у них есть своя WM, которая не поддерживает re-parenting - LG3D. Поэтому в Swing были встроены механизмы для определения WM и использования Swing как нужно для верного отображения на ней.
Нужно всего то дать приложению думать что у нас LG3D.

wmname LG3D && ./rubymine.sh

wmname - утилита из пакета suckless-tools.

После этого оно работает, запускается.

Первое что бросается в глаза - ШГ(да-да, шрифты - говно). Хотя, конечно, кого-то быстрее вырвет от оформления, оно здесь тоже не на много лучше чем шрифты.

На этом я заканчивал свои приключения. Однако, в венде оно выглядит лучше, да и люди используют, значит можно сделать и лучше, не так ли?

ШГ
Правится очень просто, как и во всех "жаба"-приложениях:

-Dawt.useSystemAAFontSettings=lcd

или сразу

env _JAVA_OPTIONS="-Dawt.useSystemAAFontSettings=lcd" ./rubymine.sh

Но можно и просто добавить "-Dawt.useSystemAAFontSettings=lcd" в файл rubymine.vmoptions в директории bin "идеи".

Везде советуют строчку "-Dawt.useSystemAAFontSettings=on", но, как оказалось, оно не везде работает и проще указать сразу lcd.

Оформление

Вообще, я могу посоветовать GTK+, но оформление меняется не всё, да и если и меняется, то иногда даже более уродливо становится.
Вот здесь всё... веселее.
Первое, что нужно понять, так это то, что в Swing(а это и есть графический тулкит, на котором построена "идея") нет понятия "тема оформления", но есть LAF'ы (Look And Feel менеджеры): Motif, Alloy, jGoodies, GTK+ etc. Все они дают наборы уже самих тем.

Небольшое отступление по поводу Swing
Swing имеет массу проблем рендерринга. Основная проблема, из-за которой всё тормозит и нет смысла что-то делать ещё - метод рендерринга в Java2D. А там он делается просто: все виджеты рендерятся софтварно и откладываются в память, а затем передаются менеджеру выше(Xorg) в виде битмапы. Из-за этого как-раз и происходят проблемы во время смены темы в Swing-приложениях(например, тема не полностью меняется, потому что некоторые изображения кешированы и отдаются сразу, а не ререндерятся с новой темой оформления).
Было много бесед на тему Java2D, но "знатоки" решили не трогать, так и приходится жить.
Стоит отметить что SWT(который используется в Eclipse) лишён данной проблемы.

Всё, казалось бы, очень просто: нужно найти хорошую тему для одной из LAF или найти хороший LAF с хорошей темой.
Это просто!
Вот есть офигенный LAF: https://substance.dev.java.net/
В 2005ом году его можно было использовать(история успеха), а вот сейчас уже нет. Дело в том, что IDEA:
1) Использует тучу собственных виджетов, которые просто не будут изменены через обычные LAF для Swing.
2) Использует собственные костыли-обвязки(точно сказать не могу, лучше спросить у знатоков) для стандартных LAF.
Я уже хотел смириться с тем, что придётся использовать тему Graphite из состава Substance, но оказалось что и её применить не смогу из-за двух пунктов выше.
Я бы хотел поэкспериментировать ещё немного, но понимаю что нет смысла, ведь есть даже открытые репорты, на которые есть ответы и нет решений:
http://youtrack.jetbrains.net/issue/PY-2032
http://youtrack.jetbrains.net/issue/IDEABKL-5514
http://youtrack.jetbrains.net/issue/IDEA-62247
http://devnet.jetbrains.net/thread/289737

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

Справедливости ради стоит отметить что подсветка кода шикарная, есть много вариантов и все шикарны.

В принципе, меня может быть и устроит тема XP, но только в офисе.
Тем не менее, вот что получилось:

И просто чтобы было с чем сравнивать, вот скрин полностью устраивающей Aptana Studio 3(eclipse-based):

Ruby. Изучение.

2010-12-21T13:07:00.000-08:00

Здесь буду публиковать информацию о том, что я читал, изучал и сколько да на что времени ушло.

http://www.linuxshare.ru/docs/devel/languages/ruby/ruby.html
~ 1 день.

http://rusrails.ru/
Первый блок статей + деталями из других - 1 день.

TO-DO:
Дочитать все блоки с русрейлс.
Изучить paperclip.
Formastic.
Nifty-generators.
Devise.
Cancan.
Active Scaffold.
To be free.

RoR3. Хорошие плагины.

2010-12-21T12:43:00.000-08:00

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

Вот некоторый набор плагинов, которые я нашёл в сети и планирую использовать.

Devise

Это офигенная система аутентификации. Большая, сильная, удобная, хоть и не столь динамичная. Она даёт всё что нужно из коробки, а главное, поддерживает OmniAuth, что означает поддержку всех существующих систем аутентификации! OAuth, OpenID etc. Что хорошо, в OmniAuth плагины для разных систем пишутся достаточно быстро и удобно, благо идея позаимствована у Repoze.Who.

Возможно, кому то не очень нравится Devise, но если хочется делать современные сайты, то альтернатив нет.

Сразу ссылка на ман для работы с OmniAuth и ещё ссылка на статью о использовании этого "в бою".

Ну и пара скринкастов: один и два.

Formtastic

Конечно, RoR и так даёт не плохие средства для клепания форм, но не всегда хватает их возможностей. Здесь и появляется "формастик". Это плагин, который упрощает создание форм до нельзя. Удобно, быстро, качественно, динамично - это всё о данном плагине.

Увы, конечно, это не Active Scaffold, но если нет требования в аяксе, этот плагин обязан быть в любом проекте.

Nifty-generators

Небольшой по функционалу плагин. Просто набор из генераторов для скаффолдинга. Стоит отметить что есть пара нужных генераторов, в числе которых генератор для обычного скаффолдинга, генерирующий сразу haml и более удобные формочки. Ещё есть генератор слоёв, который делает сразу sass.

Есть генератор для authlogic, но если используется Devise, то нафиг оно нужно.

Active Scaffold

Иногда требуется применение аякса для форм и не только. Active Scaffold позволяет делать это красиво и быстро.

Даже нечего добавить. Хотя есть что: оно большое и сложное.

Paperclip

Практически любой проект требует возможности аплоада файлов. Данный плагин позволяет сделать аплоад изображений лёгким и простым делом: сам всё ресайзит, делает тамбнейлы, даёт валидатор etc.

CanCan

Наверно, это лучший плагин для авторизации, который я когда-либо и где-либо видел. Да-да, он позволяет управлять группами и разрешениями пользователей. Это даже лучше чем Repoze.What.

Список аналогов хабра у "них"

2010-12-20T05:27:00.000-08:00

http://habrahabr.ru/qa/3230

На данный момент там такие ссылки:

slashdot.org
readwriteweb.com
engadget.com
gizmodo.com
techcrunch.com
maketecheasier.com
smashingmagazine.com
techrepublic.com.com

Ruby. Ссылки

2010-12-20T05:24:00.000-08:00

А здесь будут ссылка на всякое разное по руби и РоР.

Учебник по рубям. Мало, куча воды, написано для чайников, но сойдёт.
http://www.linuxshare.ru/docs/devel/languages/ruby/ruby.html

Офигенный английский тутор по РоР
http://railstutorial.org/

Русский аналог. Очень и очень много полезного.
http://rusrails.ru/

Применение RadRails(Aptana).
http://vimeo.com/channels/radrails

Описание деплоймента RoR в uWSGI с nginx
http://projects.unbit.it/uwsgi/wiki/RubyOnRails

ActiveScafflod. Офигенная штучка, позволяющая делать всё через аякс.
http://activescaffold.com/

Гайды по RoR
http://guides.rubyonrails.org/

ExtJS(Sencha). Ссылки

2010-12-17T16:04:00.000-08:00

С чего начать.
http://www.sencha.com/learn/Tutorial:Ext_StartUp_Guide

Создание и управление темами
http://www.sencha.com/products/js/themes.php

Валидаторы:
Дополнительные VTypes(валидаторы): http://kubuskus.blogspot.com/2009/01/some-of-extjs-vtypes.html
Пример с валидаторами: http://dev.sencha.com/deploy/dev/examples/form/adv-vtypes.html
Обычные валидаторы: http://blog.adampresley.com/2008/advanced-data-validation-using-extjs/
ReCaptcha: http://abrdev.com/?p=775

ExtJS для jQuery-разработчиков.
http://www.ajaxray.com/blog/2009/04/05/extjs-quick-start-guide-for-jquery-developers-javascript-howto/

WebDev. Хинты для вебдева

2010-12-17T15:38:00.000-08:00

Офигенный мастер для border-image из CSS3. Помогает выбрать параметры в css для лучшего стыка изображения. Есть предпросмотр!
http://border-image.com

Самый лучший и полный рецепт стики-футера.
http://www.cssstickyfooter.com/

Фреймворк фиксов для IE6. Не такой и большой функционал, но есть что использовать.
http://css3pie.com/

CSS-фреймворк. Создан быть объект-ориентированным, но на деле не так и полезно.
https://github.com/stubbornella/oocss

Хороший шаблон для написания приложений на HTML5.
http://html5boilerplate.com/

PNG htc fix
http://www.twinhelix.com/css/iepngfix/demo/
(сдвигает некоторые пикчи на 10 пикселей вниз)

Хинт для задания минимальной ширины страницы при блочной верстке.

#wrapper {
    width: expression((documentElement.clientWidth||document.body.clientWidth)<1000?'1000px':''); /*Internet Explorer <= 6.0 */
    min-width: 1000px; /* Opera & FireFox & Safari & Google Chrome & Internet Explorer 7+ */
}

Таблица дивов через список.
http://www.positioniseverything.net/explorer/escape-floats.html

Вводная по CSS
http://ru.html.net/tutorials/css/lesson1.php

CSS. Шрифты

2010-12-16T08:50:00.000-08:00

Ребята, запомните наконец список шрифтов в вебе, который можно использовать:

Arial	face="Arial"
Arial	face="Arial Black"
Comic Sans MS	face="Comic Sans MS"
Courier New	face="Courier New"
Georgia	face="Georgia"
Impact	face="Impact"
Times New Roman	face="Times New Roman"
Trebuchet MS	face="Trebuchet MS"
Verdana	face="Verdana"

via http://www.irational.org/APD/cyber/htmlfont.htm

Хинт: их должно быть 9. via Yurtaev

Важно запомнить одно: в браузерах всегда предусматривается верная обработка данных шрифтов(спасибо ie).

Если попе хочется больше, то используем ТОЛЬКО Google WebFonts, не нужно придумывать свои костыли и использовать сниппеты за 2002ой год. В гугле всё проверено и можно ни о чём не думать, даже о хостинге шрифтов!

Google WebFonts

^ Да, вот эта ссылка ^

Python. Циклические зависимости.

2010-12-14T19:13:00.000-08:00

Если циклические ссылки(зависимости) не убрать и иначе их не избежать, то в модулях, где эти ссылки используются ТОЛЬКО в рантайме(в функциях, например), необходимо передвинуть импорт ссылки в КОНЕЦ файла.

Daily Shit: Внутренности пайтона. Класс abc.

2010-12-14T18:53:00.000-08:00

В который раз столкнулся со внутренностями CPython и получил фейспальму.
Дело в том, что для фреймворка нам необходимо использовать интерфейсы. Сразу было понятно что abc нам не хватит, поэтому надо было что-то бОльшее. Был рассмотрен zope.interface, но не устроило то, что для имплементирывания класса нужно вызывать функцию implements в теле класса, что не очень красиво. Увы, такие вещи для многих становятся критичными во время выбора инструмента и могут послужить минусом для фреймворка в целом.

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

Казалось бы, всё просто. Однако, эксепшн мало о чём говорит. Забавно, но эксепш даже не специального типа, а просто TypeError. Чтобы проанализировать что и как, нужно было бы посмотреть сырец модуля abc. Однако, достаточно просто грепнуть abc.py по raise чтобы понять что abc.py это не всё, а сама ошибка берётся откуда-то ещё. Оказалось что всё сложнее, что корни abc лежат в сырцах CPython.
Греп по сырцам CPython сразу дал ответ — typeobject.c. В общем, вот что нам интересно:


static PyObject *
object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    int err = 0;
    if (excess_args(args, kwds)) {
        if (type->tp_new != object_new &&
            type->tp_init != object_init)
        {
            err = PyErr_WarnEx(PyExc_DeprecationWarning,
                       "object.__new__() takes no parameters",
                       1);
        }
        else if (type->tp_new != object_new ||
                 type->tp_init == object_init)
        {
            PyErr_SetString(PyExc_TypeError,
                "object.__new__() takes no parameters");
            err = -1;
        }
    }
    if (err < 0)
        return NULL;

    if (type->tp_flags & Py_TPFLAGS_IS_ABSTRACT) {
        static PyObject *comma = NULL;
        PyObject *abstract_methods = NULL;
        PyObject *builtins;
        PyObject *sorted;
        PyObject *sorted_methods = NULL;
        PyObject *joined = NULL;
        const char *joined_str;

        /* Compute ", ".join(sorted(type.__abstractmethods__))
           into joined. */
        abstract_methods = type_abstractmethods(type, NULL);
        if (abstract_methods == NULL)
            goto error;
        builtins = PyEval_GetBuiltins();
        if (builtins == NULL)
            goto error;
        sorted = PyDict_GetItemString(builtins, "sorted");
        if (sorted == NULL)
            goto error;
        sorted_methods = PyObject_CallFunctionObjArgs(sorted,
                                                      abstract_methods,
                                                      NULL);
        if (sorted_methods == NULL)
            goto error;
        if (comma == NULL) {
            comma = PyString_InternFromString(", ");
            if (comma == NULL)
                goto error;
        }
        joined = PyObject_CallMethod(comma, "join",
                                     "O",  sorted_methods);
        if (joined == NULL)
            goto error;
        joined_str = PyString_AsString(joined);
        if (joined_str == NULL)
            goto error;

        PyErr_Format(PyExc_TypeError,
                     "Can't instantiate abstract class %s "
                     "with abstract methods %s",
                     type->tp_name,
                     joined_str);
    error:
        Py_XDECREF(joined);
        Py_XDECREF(sorted_methods);
        Py_XDECREF(abstract_methods);
        return NULL;
    }
    return type->tp_alloc(type, 0);
}

И сами методы


static PyObject *
type_abstractmethods(PyTypeObject *type, void *context)
{
    PyObject *mod = NULL;
    /* type itself has an __abstractmethods__ descriptor (this). Don't return
       that. */
    if (type != &PyType_Type)
        mod = PyDict_GetItemString(type->tp_dict, "__abstractmethods__");
    if (!mod) {
        PyErr_Format(PyExc_AttributeError, "__abstractmethods__");
        return NULL;
    }
    Py_XINCREF(mod);
    return mod;
}

static int
type_set_abstractmethods(PyTypeObject *type, PyObject *value, void *context)
{
    /* __abstractmethods__ should only be set once on a type, in
       abc.ABCMeta.__new__, so this function doesn't do anything
       special to update subclasses.
    */
    int res = PyDict_SetItemString(type->tp_dict,
                                   "__abstractmethods__", value);
    if (res == 0) {
        PyType_Modified(type);
        if (value && PyObject_IsTrue(value)) {
            type->tp_flags |= Py_TPFLAGS_IS_ABSTRACT;
        }
        else {
            type->tp_flags &= ~Py_TPFLAGS_IS_ABSTRACT;
        }
    }
    return res;
}

Как видно из сырцов, abc это не что-то внешнее, это часть пайтона. Вся реализация идёт через установку объекту флага Py_TPFLAGS_IS_ABSTRACT.
Флаг ставится только при вызове сеттера __abstractmethods__ и если value является сетом:


int res = PyDict_SetItemString(type->tp_dict, "__abstractmethods__", value);

Самое интересное же оказалось в методе __new__, где всё делается просто как 2 копейки:


PyErr_Format(PyExc_TypeError,
    "Can't instantiate abstract class %s "
    "with abstract methods %s",
    type->tp_name,
    joined_str);

Собственно, суть в том, что нужно сразу после создания конечного класса(который имплементирует функции) объявить список абстрактных функций через присваивание списка полю __abstractmethods__. Не сделали — ничего и не будет.
А теперь о том, как работает abc сейчас:
1) Создаётся интерфейс с метаклассом ABCMeta. В момент его создания, вызывается метод __new__ мета-класса, который обрабатывает содержимое класса и инициализирует __abstractmethods__. Тадам! Поставили флаг что данный класс — абстрактрый.
2) Создаётся имплементация интерфейса через наследование интерфейса. Повторно вызывается метод __new__ метакласса интерфейса! Собственно, тогда и делаются все нужные чудеса.
3) В CPython райсится эксепшн.
Собственно, что осталось сделать — отловить эксепшн в __call__, определить какой метод не имплементирован и вывести его докстринг.

Такие дела. Вот только то, как оно внутри всё устроено, мне очень не понравилось. Одно хорошо — отделались не такой большой кровью.

Результаты трудов можно наблюдать среди "адаптаций" в agatsuma - здесь.
Если вы хотите чтобы наша версия обёртки для абстрактных классов была включена в agatsuma.commons, то можете отписать об этом в багтрекер, ибо только моего голоса не хватит чтобы образумить второго разработчика агатсумы.

P.S.: Это старый документ, запощеный в juick, может где-то что-то не так.

Python. Синглтоны.

2010-12-14T08:43:00.000-08:00

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

В конце статьи мы дойдём до реализации синглтонов на пайтоне так, чтобы они было красиво и всех устраивало.

UPD1: Реализация переписана на метаклассы. Смотри в самый низ статьи.
UPD2: Добавлен хинт для адресации к переменным сразу через dot: Foo.name (было: Foo().name).

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


a = "hello"
b = "goodbye"

def b.upcase
    gsub(/(.)(.)/) { $1.upcase + $2 }
end

puts a.upcase #HELLO
puts b.upcase #GoOdBye

via Wyldrodney
Во второй строке создаётся сам объёкт, который будет синглтоном, в 4ой добавляется метод и объект становится синглтоном(только у нас в голове, конечно). В девятой строке демонстрируется как оно работает.
Красиво? Нет/иногда. Практично? Иногда. Синглтон ли это? Нет.

Однако, поддерживаются и классические одиночки, которые мы так любим в CPP, Java.


require 'singleton'
class Test
    include Singleton
    def message(msg)
        puts msg
    end
end

Test.instance.message('test')

via Yumitsu
Импортируем модуль, добавляем методы, обращаемся через получаемый член instance. Стоит обратить внимание на то, что класс уже инициализирован.

В пайтоне синглтонами тоже привыкли называть нечто иное. В "стеке" все ссылкаются на один и тот же вопрос, а точнее выбранный ответ.
Сама суть данного метода описана здесь.
Коротко говоря:
Синглтонами в пайтоне называют модули с глобальными переменными и функциями(без классов). Своё состояние они хранят в глобальных переменных.


inited = False

def init(files=None):
    global inited
    db = MimeTypes()

Инициализируем переменные, обращаемся к ним.

Однако любого программиста смутит данный способ, ровно как и способ из руби. В отличии от руби, в пайтоне нет стандартного модуля синглтонов. Поэтому, я решил что стоит сделать свой в составе библиотеки agatsuma.commons.

Для начала, следует определить что такое "хорошо", т.е. как мы хотим чтобы выглядело использование синглтонов.


class Foo(Singleton):
    def __init__(self, arg):
        self.arg = arg
        print arg, 'inited!'
    def test(self):
        print self.arg
Foo(1).test() => 1 inited!\n1
Foo().test() => 1

Наследуем базовый тип, который делает всё что нужно. При вызове конструктора класса, первый раз вызывается __init__, остальные разы возвращается один и тот же инстанс, который был создан с самого начала.
В силу того, что пайтон поддерживает множественное наследование, это достаточно удобный вариант. Удобнее чем указание метакласса.

Ну давайте двигаться к цели!
Первое, что мог найти либой человек попробуя погуглить, это статья в вики и данный код:


class Singleton(object):
    obj = None                           # Атрибут для хранения единственного экземпляра
    def __new__(cls,*dt,**mp):           # класса Singleton.
       if cls.obj is None:               # Если он еще не создан, то
          cls.obj = object.__new__(cls,*dt,**mp) # вызовем __new__ родительского класса
       return cls.obj                    # вернем синглтон

Суть: перегрузка метода __new__, который создаёт инстанс. Если инстанс есть - возвращаем его, нет - создаём.
Вот только есть проблема.
DeprecationWarning: object.__new__() takes no parameters
Что это значит, почему и как, было обсуждено в рассылке python-dev.

The message means just what it says. :-) There's no point in calling
object.__new__() with more than a class parameter, and any code that
did so was just dumping those args into a black hole.

The only time when it makes sense for object.__new__() to ignore extra
arguments is when it's not being overridden, but __init__ *is* being
overridden -- then you have a completely default __new__ and the
checking of constructor arguments is relegated to __init__.

The purpose of all this is to catch the error in a call like
object(42) which (again) passes an argument that is not used. This is
often a symptom of a bug in your program.

--Guido

В общем, вики требует правки.
Цель "object.__new__(cls,*dt,**mp)" - создать экземпляр класса передавая аргументы в его конструктор.
Стоит отметить особенность пайтона: Сначала вызывается __new__, а потом, с теми же аргументами, __init__. Нет нужды передавать аргументы в object.__new__.

Код становится такого вида:


class Singleton(object):
    __instance = None
    def __new__(cls, *a, **kwa):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

Однако, из предыдущей особенности становится логично что вытекает ещё одна: не важно какой инстанс был возвращён в __new__, __init__ всё-равно будет вызван.
Я много думал о решении данной проблемы, но самое лёгкое - удаление __init__ из класса после выполнения инициализации.
По идее, надо бы удалять его сращу после выполнения, но это мы можем сделать только в __init__, но там что-то делать будет не так красиво.
Можно, конечно, сделать свой __init__ в синглтоне, который будет вызывать другой метод, который и будет самим конструктором.
Например:


class Singleton(object):
    __instance = None
    __inited = False
    def __new__(cls, *a, **kwa):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance
    def __init__(self, *a, **kwa):
        if not self.__inited and hasattr(self, "_init"):
            self._init(*a, **kwa)
            self.__inited = True

Тогда использование будет таким:


class Foo(Singleton):
    def _init(self, arg):
        print arg

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


nullfunc = lambda x: None

class Singleton(object):
    __instance = None
    __init_replaced = False
    def __new__(cls, *a, **kwa):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
            
        elif not cls.__init_replaced:
            cls.__init__ = nullfunc
            cls.__init_replaced = True
            
        return cls.__instance

Удалить __init__, увы, нельзя, но можно его заменить. Чтобы не менять его каждый раз, сделаем флаг(5).

Однако, данный вариант грязен, не так красив и вообще может кого-то смутить своим видом.

Есть и альтернативный путь - реализация через перегрузку метода __call__ метакласса синглтона.
Дело в том, что при каждом вызове(а точнее перед) конструктора класса, вызывается метод __call__ метакласса. Да! Это то что нам нужно. Не буду томить, вот готовый код:


class SingletonMeta(type):
    def __init__(cls, name, bases, dict):
        super(SingletonMeta, cls).__init__(name, bases, dict)
        cls.instance = None 
    def __call__(self,*args,**kw):
        if self.instance is None:
            self.instance = super(SingletonMeta, self).__call__(*args, **kw)
        return self.instance

class Singleton(object):
    __metaclass__ = SingletonMeta

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

Отдельно хочется добавить что сам метакласс был взят из поста в "стеке", за что автору спасибо.

И для самых капризных осталось добавить ещё 2 возможности:
1) Адресация к переменным через Foo.name вместо Foo().name
2) Вызов функций класса через Foo.name() вместо Foo().name()

Первое решается просто добавлением в мета-класс перегруженного метода __getattr__:


def __getattr__(cls, name):
    return getattr(cls(), name)

Однако, второй пункт реализовать я пока не смог. Если у вас есть идеи - с удовольствием выслушаю.

Вот и всё. Есть вопросы? Задавайте здесь, в комментах.

Конечный вариант можно наблюдать в сырце из пакета agatsuma.commons.

Check em

2010-12-14T07:03:00.000-08:00

Hmmm


public void printHello(){
System.out.println("Hello World");
}


class Singleton(object):
    __instance = None
    def __new__(cls, *a, **kva):
        '''
        Singleton getter/creator
        @return: Class instance
        '''
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        else:
            cls.__init__ = lambda x: None
        return cls.__instance


function helloWorld() {
  alert(‘Hello World!’);
}
function helloWorld() {
  alert(‘Hello World!’);
}
function helloWorld() {
  alert(‘Hello World!’);
}


public void printHello(){
System.out.println("Hello World");
}

Хайлайт, который я юзаю в этом блоге:
http://alexgorbatchev.com/SyntaxHighlighter/

Что нужно сделать чтобы он заработал в блогспоте:
http://fahdshariff.blogspot.com/2009/09/upgrading-to-syntaxhighlighter-20.html

Хостинг хайлайтера:
http://alexgorbatchev.com/SyntaxHighlighter/hosting.html
http://alexgorbatchev.com/pub/sh/current/

Репост в твиттер + лента:
http://angel2s2.blogspot.com/2010/07/twitter-c-blogger-jabber.html

Ручные фиксы в css блогспота:


/* Делаем форму комментариев шире, чтобы было более удобно набирать
 длинные комменты, ведь форму просто так не раздвинуть в хромиуме,
 там таблица(или див, не помню) мешает */
.comment-form {
    max-width: 100%;
}

/* Убираем скроллбары в блоге. Я лично не использую вставок, где они
 нужны, поэтому мне пофиг. Однако это очень полезно если какой-то из
 стилей блогспота/хайлайтера заставляет появляться скроллбар для
 скроллинга 1.5 пикселей. */
.syntaxhighlighter{
    overflow-y: hidden !important;
}