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

Меня довольно сильно заботит вопрос распределения времени форумчан и разных знакомых в течение рабочего дня. Мне кажется, что 5 дней в неделю по 8 часов безотрывно разрабатывать невозможно. Надо отойти там в туалет, каждый час отвлекаться от ПК на 5 минут для отдыха глазам, отпроситься пораньше или прийти попозже в связи с личными делами. У меня довольно сильно возникает впечатление, что я на рабочем месте часто занимаюсь не тем. Ведь работодатель платит за решение конкретных рабочих проблем. И если я отвлекаюсь от непосредственно разработки, то постоянно жду удара и внезапного увольнения. Из-за этого довольно нервный, удивляюсь тем, кто работает спокойно.

- Сколько у вас уходит времени на разработку? Т.е. печатать, подумать, порыться в доках и форумах по текущей рабочей задаче.

- Как вы относитесь ко всяким новостям в течение дня, типа какого-то чрезвычайного происшествия? Самолет упал или загорелся ТРЦ. И пара часов куда-то испаряется. Вроде и работал, но в каком-то вялом темпе.

- Что, если вы наткнулись на какую-то интересную историческую статью в течение дня? Мне думается: подумаешь, 15-20 минут почитаю, не убудет. А потом мучает совесть, что спустил это время в неоплачиваемую трубу.

- Как у вас с отвлечениями на всякие политические темы? Очевидно, платят не за это. Но это цепляет, это заботит, это интересно. И минут 40 как не бывало.

- Милая ерунда, типа котиков и шуточек. Минут 10-15. Не каждый день. Пускай или гнать такого в шею?

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

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

- Чтение литературы. Когда? В нерабочее время очень трудно, да и не хочется уделять этому время. Всё-таки жизнь - это не только разработка, есть миллион других вопросов, проблем и интересов. Не понимаю тех, кто перечитал все книги по плюсам, линуксам, познакомился с бустами и новыми стандартами. КАК? Надо же готовить еду, покупать продукты, подбирать шмотки чуть лучше бомжа, навещать родню, налаживать личную жизнь, ходить в походы и рыбалки, сажать и убирать картошку, как-то разгружать глаза и т.д. и т.п. А в рабочее время - как бы платят не за чтение книг. Почитал за пару часов десяток страниц, а задача не сдвинулась.

- Поражаюсь тем, кто читает по паре книг в месяц. Я одну захудалую книжонку полгода читаю. Кто вы вообще? У вас есть в жизни что-то, кроме книг?

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

У меня большие сомнения в своей профпригодности, когда вижу супергероев. Как вообще за вами угнаться? Как потом пройти у вас собеседование? Как не вылететь?

Перемещено tailgunner из development

Как определяется, в какую сторону должно быть обобщение?

То есть, при решении конкретной задачи как определить, что должно быть параметром, а что — неизменяемой частью.

Например, есть задача «получить сумму от 1 до 100».

Самым быстрым решением будет

class Sum1_100
{
  int run() { return 5050; }
}

но в этом случае программист поработал за компьютер. Тривиальное решение с расчётом компьютером

class Sum1_100
{
  int run() 
  { 
    int res = 0; 
    for(int i=1; i<=100; i++) res+=i; 
    return res; 
  }
}

Но получив такую задачу, почти всегда решение выглядит примерно так:

class Sum1_n
{
  int n;
  Sum1_n(int _n = 100) { n = _n; };
  int run() 
  { 
    int res = 0; 
    for(int i=1; i<=n; i++) res+=i; 
    return res; 
  }
}

на случай, если потребуется не до 100, а до какого-то другого числа.

И вот здесь у меня вопрос: почему в «получить сумму от 1 до 100» большинство параметризуют именно 100? Посему не «сумму» (тогда параметром будет операция от 100 элементов) или не «от 1 до 100» (тогда параметром будет некая последовательность). Или вообще не всё сразу? С вызовом типа

  auto_ptr<Op> op = new GenOp(operator+, 100);
  auto_ptr<Seq> seq = new Seq(1, 100);
  auto_ptr<Apply> = new GenApply(op, seq);
  result = Main->run();

Как для произвольного алгоритма определяется, что является параметром, а что неизменяемой частью?

Пишу используя джангу и питон около года, последнее время начал посматривать на ror из-за mvt в джанге и очень вкусного mvc в рельсах. Руби не нравился изза обилия сахара и неразвитости руби в общем применении (в отличие от питона)
Куда пойти за более изящной структурой, развитостью инфраструктуры, наличием best practices? Ruby/RoR или Python/другой фреймворк? Или остаться на джанге и ждать релизов?

Интересуют именно ruby/python

Всем доброго времени суток!

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

Заранее спасибо).

PS. В качестве СУБД используется MySQL.

python2.7

list = []
def fn1(x=1):
   def fn2():
      print x
   y=fn2
   list.insert(0,y)
fn1()
ref_to_fn2 = list[0]
ref_to_fn2()

def fn2():
   print x
   x=2

Можно ли в Racket в макросе объявить функции, которые бы использовала вложенная в этот макрос функция?

т.е.

(define-syntax some-shit
 (syntax-rules ()
 [(some-shit a b)
  ((lambda() 
    (define proc1 "ok")
    (define proc2 "ok2")
    (a b)))]))

И в другом пакете:

 (some-shit (lambda (val) (string-append proc1 b))
            "heheh")

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

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

Вот я попробовал сейчас из линукса вот такое сделать:

CL-USER> (let ((file #P"file.txt"))
                (with-open-file (*standard-input* file)
                  (with-open-file (in file)
                    (read-char *standard-input*)
                    (read-char in)
                    nil)))
NIL
CL-USER> 

и вроде никаких проблем.

Я помню винду с её жуткими придирками по поводу занятости файлов работами в приложениях и есть вопрос: а насколько будут такие фокусы кросплатформенны?

PERCHAR-VS-BUFFERING> (format t "~A-~A~%"
                              (lisp-implementation-type)
                              (lisp-implementation-version))
SBCL-1.3.20
NIL

Код здесь: https://pastebin.com/f6RtgQPE

Заранее извиняюсь за на коленке налабанный говнокод.

Для экспериментов нашёл свою старую курсовую в LaTeX и, редактируя и копипастя, раздул файл до 200M.

Вот результаты экспериментов у меня:

PERCHAR-VS-BUFFERING> (let ((*buffer-size* (* 4 (expt 2 10))))
                        (time
                         (with-open-file (*standard-input* #P"text3.tex")
                           (let ((lv (multiple-value-list (run-perchar))))
                             (setf *x* lv)
                             (first lv)))))
Evaluation took:
  4.092 seconds of real time
  4.092759 seconds of total run time (4.042829 user, 0.049930 system)
  100.02% CPU
  9,427,500,968 processor cycles
  7,733,248 bytes consed
  
114337080
PERCHAR-VS-BUFFERING> (defparameter *x2* *x*)
*X2*
PERCHAR-VS-BUFFERING> (let ((*buffer-size* (* 4 (expt 2 10))))
                        (time
                         (with-open-file (*standard-input* #P"text3.tex")
                           (let ((lv (multiple-value-list (run-with-buffering))))
                             (setf *x* lv)
                             (first lv)))))
Evaluation took:
  3.162 seconds of real time
  3.162505 seconds of total run time (3.117984 user, 0.044521 system)
  100.03% CPU
  7,284,480,890 processor cycles
  7,765,280 bytes consed
  
114337080
PERCHAR-VS-BUFFERING> (equal *x* *x2*)
T
PERCHAR-VS-BUFFERING> 

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

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

PS для некоторых проверок запускал wc -m. Хотя задача у него гораздо проще чем у реализаций на CL, но что примечательно - он проигрывал в скорости от самой медленной реализации на CL более чем на 800 мс.

PS2 Жирный и тупой троллинг от хомячков т.н. мейнстрима и других д**ов здесь не нужен

В частично упорядоченном множестве хочу быстро узнавать, верно ли, что А<Б. Видимо, для этого надо построить какой-то индекс и пользоваться им. Какой? Как его быстро построить?

Пока нашёл вот это: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.6760&rep=rep1... но даже не смотрел. Мне кажется, это должно быть в каком-то учебнике, который я не читал.

Всем привет

Объясните плз, в чем преимущество git перед svn, если используется централизованный репозиторий кода? Пришел на проект. В нем 2 разработчика, используют гит, разработчики друг с другом сливали между собой изменения.

Я в проекте реализую отдельную функциональность, для которой уже развернут svn-репозиторий. Я сразу был этому рад, так как никаких религиозных проблем с выбором vcs не имею, но svn знаю намного лучше git. Спросил у коллег, почему они его не используют. Ничего внятного мне не сказали, одно мычание. В их группу пришел еще один разработчик - они задумались над централизованным репозиторием, но это должен быть git-репозиторий. Обсуждают возможность купить корпоративный акк на gitbucket, на мои вопросы о целесообразности отвечают что я просто люблю svn, а им нравится git.

И да, они используют TortoiseGit для работы :-) Позже я узнал, что этот хайп с гитом накрыл практически всю контору в других городах. Теперь уже мне приходится объяснять, почему я использую svn вместо git.

Чего в гите такого крутого?

Предыстория в двух словах: Забиндил переключение буферов, хочу без дополнений игнорировать «*» буферы.

Выдрал на просторах кусок конфига:

;; Removes *scratch* from buffer after the mode has been set.
(defun remove-scratch-buffer ()
  (if (get-buffer "*scratch*")
      (kill-buffer "*scratch*")))
(add-hook 'after-change-major-mode-hook 'remove-scratch-buffer)

;; Removes *messages* from the buffer.
(setq-default message-log-max nil)
(kill-buffer "*Messages*")

;; Removes *Completions* from buffer after you've opened a file.
(add-hook 'minibuffer-exit-hook
      '(lambda ()
         (let ((buffer "*Completions*"))
           (and (get-buffer buffer)
                (kill-buffer buffer)))))

Когда я открываю файл и если открывается буфер *Completions*, просмотр папок, то строки ;; Removes *scratch* автоматом его закрывают.
Сумбурнополучилось, кхм. Как тестил: комментировал этот кусок и всё работает, только он в памяти висит, пока руками не убьёшь.

Задача - автоматически закрывать буфер *scratch* после открытия файла.

Я не знаток LC, но немного знаком, и возник вопрос: а существуют ли безымянные функции в LC? Ведь, по факту, в LC, каждая функция, четко связана со своим аргументом, через который она передается, а значит, абсолютно каждая функция в LC, имеет свое имя. Однако, безымянные ф-ции, в ЯП, обычно выдаются за фичу LC. Фактически, есть даже устоявшееся значения слова «лямбда», в смысле, «безымянная ф-ция».

Насколько я понимаю, выражение, подобное этому, например:

(define foo ((lambda(x) (lambda(y) (x y)))) (lambda(x) x))

Я пытаюсь найти пример, по которому можно четко понять преимущество мультиметодов над одиночной диспетчеризацией и message-passing. Оговорюсь, на всякий случай, что это преимущество я не пытаюсь отрицать, просто до меня пока не доходит.

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

https://ru.wikipedia.org/wiki/Мультиметод#Common_Lisp

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

Затем я пытался понять преимущество мультиметодов на этом вот примере из PCL

http://spline-online.tk/wiki/doku.php?id=pcl:chapter16#defmethod

С банковским «приложением», но снова ничего не понял. Все что там показывается, без мультиметодов, по моему, будет не хуже, и не сложней.

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

Подскажите пожалуйста, где можно такое найти, или, если не трудно, приведите пример, демонстрирующий преимущество.

Смотрю в википедию, отличий не нахожу. Если так, то почему в википедии не упомянуты Си и Common Lisp?

Собственно, когда-то очень давно пользовался MASM'ом (верси 6.11, если мне склероз не изменяет), так там был встроенный макроязык, который сначала было очень трудно освоить, но зато после того, как я им проникся, я начал писать асм-код в разы быстрее, поскольку генерировал львиную часть кода именно им.

И давеча подумал я на досуге: вот мне трудно осваивать LISP с нуля, но если бы он был встроен в какой-то другой язык, вполне себе общего назначения - скорее всего мало-помалу я бы стал использовать его всё больше и больше и в конечном итоге код на LISP'е стал бы как и в случае с макроассмеблером составлять вообще большую часть кода, после чего перейти на любой полнойценный LISP-based язык не составило бы труда.

Внимание, вопрос: в каком «обычном» ЯП можно использовать LISP в качестве встроенного макроязыка?

Спасибо!

Интересует мнение практиков. Поделитесь опытом, пожалуйста. Когда и для чего вы применяете STM, а когда atom или agent. Что оказывается лучше в каких ситуациях? Понятно, что если объект один, то лучше atom/agent, но вот в случае более сложных структур, что обычно предпочтительнее, завести группу ссылок и действовать через stm или же сгруппировать данные в структуру и завести один atom/agent для этого? Чем руководствоваться в выборе? Есть ли исследования и полезные ссылки?

Хотелось бы что-то вроде такого:

«После того, как неинициализированной переменной $a будет присвоено значение, вызвать вот такой метод объекта».

Поясню смысл:

Я могу наследовать объект, это прекрасно.

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

Но ещё я чаще всего не хочу в принципе ничего модифицировать глобально в самом объекте, а хочу, например, знать, что у него там в кишках происходит. Ну, например, совершенно классический случай: исходно данный объект очень скупо логирует происходящее, а мне бы хотелось, чтобы он при несовпадении фазы луны и цвета большой медведицы - всё-таки что-нибудь полезное капнул мне в лог.

Мне, конечно, хотелось бы вставить внутрь такого объекта breakpoint, но... а что если протоколируемая ситуация происходит только в рантайме при невыясненных обстоятельствах? Или что если объект всячески использует обработчики событий, распараллеливание и пр. - и тоже интересная ситуация ни в каком дебагере не вылезает никогда, а вот в рантайме - вполне, и самым неприятным образом.

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

Почему это нужно? Почему нельзя просто переопределить метод после наследования?

Ответ простой: логика метода, как правило, не сильно меняется с течением времени, глобальный рефакторинг случается редко, и его легко заметить - поэтому достаточно высокоуровневое описание патча в духе «после инициализации переменной, сделай это» - переживёт обновления исходного класса с высокой долей вероятности. В конце-концов проблему несовместимости «патча» выявит как таковой «патчер» в языке - и либо просто не выполнит соотв. кусок кода, выдав при запуске ошибку (если проблема определяется на этапе компиляции), либо вывалит error в рантайме - плохо конечно, но для того и нужны регрессионные автотесты, чтобы предупреждать заранее подобные казусы. А вот если я переопределяю сам метод, исходно сделав тупо копипасту - то мне волей-не волей придётся потом следить за всеми «мутациями» кода класса, обновляя копипасту... и это как бы при том, что я НЕ являюсь его мейнтейнером (а может быть и не знаю его мейнтейнера)!

Хорошо, когда описанное можно сделать before или after hook'ом (например, в Perl5/Moose такие штуки есть), но плохо, когда в общем случае нужно всё-таки пропатчить объект в произвольном месте.

Вот как? Есть ли уже какие-то решения данной задачи? Насколько я отстал от жизни или почему мне не нужно то, что мне нужно?

Просветите, пожалуйста!

P.S.

Кстати, да, было бы ещё интересно не модифицировать класс, но модицифировать именно методы уже созданных инстансов класса, объектов то бишь. Ибо объектов 100500 штук и какие-то из них я хочу патчить, а какие-то - совершенно не хочу, даром не надо.

Хочу что-то типа такого:
При поиске файла ввел /h/d/pro/w/m/
А он тебе предлагает варианты типа /home/deterok/projects/work/my-project.

По-моему я такое видело в каком-то ido года 2 назад. Может кто может подсказать рецепт?

Я хочу наскрести на свою задницу проблем, и организовать домашний проект, чуть менее чем полностью состоящий из проблем в многопоточности Java. Там должен твориться реальный ад и свинец. Для обеспечения работоспособности себя подходят любые средства, включая модификацию openjdk.

Есть какие-нибудь идеи, что это может быть?
Желательно так, чтобы это еще и имело некую иллюзию смысла, потому что пилить совсем уж бессмысленную фигню будет муторно.

Цель: разобраться как в Java работает concurrency. Позадрачивать низкоуровневый перфоманс и байтоёбство. Как сказал один хороший человек - «писать код, много кода. Писать тесты, много тестов. Читать спеку до посинения, и труды, которые эту спеку интерпретируют».

Проблема в том, что в java web мире concurrency почти не встречается, а все проблемы с concurrency обычно решаются его решительным выпиливанием. Поэтому чтобы прошарить в теме недостаточно просто прийти на работу и собрать хлебальником все грабли - у нас их просто нет. А надо наскрести!

Что подскажет хайвмайнд?
С меня как всегда - ничего :)
Спасибо

Вышла версия 6.4 языка Racket — языка программирования общего назначения из семейства Lisp/Scheme.

• Исправлена уязвимость в Web-сервере. Данная уязвимость позволяла получить доступ к любому файлу, доступному Web-серверу для чтения (подробности).
• Новый инкрементальный сборщик мусора уменьшил паузы, что особенно важно в играх и анимациях.
• Скроллинг в DrRacket стал быстрее.
• Добавлен болгарский перевод в DrRacket.
• Каталог пакетов теперь имеет адрес HTTPS по умолчанию, а не HTTP.
• Документация теперь может определять свои собственные категории для главной страницы руководства с использованием строк.
• Шпаргалка по Racket включена в основной дистрибутив.
• Контракт, который Typed Racket генерирует для типа Any, стал более либеральным, что позволяет большему числу программ как с использованием системы типов, так и без неё работать без ошибок контракта.
• Redex поддерживает спецификацию связей (binding specifications).
• Все функции pict принимают pict-convertible, что обеспечивает прозрачное взаимодействие между pict и библиотеками типа 2htdp/image.
• Команды raco profile и raco contract-profile предоставляют лёгкий доступ к инструментарию профилирования без необходимости изменять сами программы.

>>> Подробности