Tagged: groovy

Скринкаст: Пишем калькулятор на Java, JavaFX, Groovy, Spock, Kotlin

Несколько вечеров за которые я написал калькулятор на Джаве с тестами на Груви а потом переписал на Котлин. Интересно будет только для Stong Junior’ов

Это не туториал! В обычных туториалах всё хорошо и сразу получается, но как только начинающий программист сталкивается с ошибкой то не знает как дальше двигаться. Здесь все по настоящему — часть я знаю, часть изучаю сразу же. На ваших глазах появляются и фиксятся баги, гуглится и копипастится с СтекОверфлоу. Это может быть вам полезно для того чтобы ощутить эвристики которые помогают мне.
Скучно, занудно — но именно так примерно мы и программируем целыми днями. Если вы думаете связать свою жизнь с этим ремеслом, можете прочувствовать себя в моей шкуре 😉

Исходный код:
https://github.com/stokito/javafx-calculator

P.S. Да, я знаю звук отвратительный, винда неудачно обнволялась и с драйвером звука какая-то ерунда.

Power Assert in Vim

Power Assert for Java and others

Peter Niederwieser, creator of Spock, the best testing framework ever, also contributed to Groovy programming language a very handy feature: Power Asserts.

int x = 1;
assert x == 2;

// Output:             
//
// Assertion failed:
// assert x == 2
//        | |
//        1 false

As you can see, we can see each value of each statement, and this is very cool, especially for unit tests.
It makes all this JUnit bullshit like assertEquals(), assertTrue, assertNull, and all matchers like Hamcrest absolutely unneeded.
I really hate all matchers like FEST or Hamcest, because they aren’t natural and repeat code itself.

So now you can breathe freely without any repeating yourself.

You can see a talk where Peter Niederwieser present Spock specifications

Also Peter created Power Asserts lib for Scala
https://github.com/pniederw/expecty

But,
Unfortunately, you can’t make a Power Asserts in Java, because it doesn’t have a AST preprocessor.

If you, like me, have a big project with tests written in Java+JUnit, the only one way that I found, is convert them to Groovy (in 99% just change file extension from Java to Groovy) or you can compile your tests with groovyc — it’s Groovy Compiler but compiles Java too as well.
After compiling with groovyc asserts in Java behaves like in Groovy. Maybe this is the only one case when something written in Java works differently when compiled with Groovy.

For example here is simple test in Java

import org.junit.Test

class UserTest {
    @Test
    public void testName() {
        String username = "olololo";
        assert username.equals("trololo");
    }

}

After compiling with groovyc it’s decompiled bytecode will looks like:

// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
import groovy.lang.GroovyObject;
import groovy.lang.MetaClass;
import org.codehaus.groovy.runtime.ScriptBytecodeAdapter;
import org.codehaus.groovy.runtime.callsite.CallSite;
import org.codehaus.groovy.runtime.powerassert.AssertionRenderer;
import org.codehaus.groovy.runtime.powerassert.ValueRecorder;
import org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation;
import org.junit.Test;

public class UserTest implements GroovyObject {
    public UserTestGroovy() {
        CallSite[] var1 = $getCallSiteArray();
        MetaClass var2 = this.$getStaticMetaClass();
        this.metaClass = var2;
    }

    @Test
    public void testName() {
        CallSite[] var1 = $getCallSiteArray();
        String username = "olololo";
        ValueRecorder var3 = new ValueRecorder();

        try {
            CallSite var10000 = var1[0];
            var3.record(username, 8);
            Object var6 = var10000.call(username, "trololo");
            var3.record(var6, 17);
            if(DefaultTypeTransformation.booleanUnbox(var6)) {
                var3.clear();
            } else {
                ScriptBytecodeAdapter.assertFailed(AssertionRenderer.render("assert username.equals(\"trololo\")", var3), (Object)null);
            }

        } catch (Throwable var5) {
            var3.clear();
            throw var5;
        }
    }
}

As you can see, it uses ValueRecorder to store all evaluated expressions and it will render a source code line. And it may be executed as class file (may require groovy-all dependency in classpath):

Assertion failed: 

assert username.equals("trololo")
       |        |
       olololo  false

	at org.codehaus.groovy.runtime.InvokerHelper.assertFailed(InvokerHelper.java:402)
	at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.assertFailed(ScriptBytecodeAdapter.java:650)
	at com.github.stokito.UserTest.testName(UserTest.java:9)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)

Unfortunately currently IntelliJ can’t compile Java files with Groovyc. It always compiles *.java files with javac.
I created an issue Allow groovyc as compiler for Java classes, please vote for it.

Power Asserts in other languages

Kotlin

does not exist but authors know about Power Assertions and had intentions to do them.

.NET languages

https://github.com/PowerAssert/PowerAssert.Net

JavaScript

https://github.com/power-assert-js/power-assert
https://github.com/power-assert-js/espower-typescript for TypeScript
https://github.com/power-assert-js/espower-babel
https://github.com/power-assert-js/babel-plugin-espower
https://github.com/twada/battlefield-sourcemaps
https://github.com/deepblue-will/coffee-power-assert for Cofee Script
https://github.com/twada/fly-espower

Ruby

There is a gem https://github.com/k-tsj/power_assert and here is presentation from author:

https://github.com/joker1007/rspec-power_assert
https://rubygems.org/gems/power_assert/versions/0.2.4
https://github.com/hsbt/minitest-power_assert
https://github.com/yui-knk/pry-power_assert for Pry REPL

Others

https://github.com/keygx/PAssert XCTest by Swift
https://github.com/rosylilly/power_assert.cr for Crystal (static Ruby)
https://github.com/ma2gedev/power_assert_ex for Elixir
https://github.com/gifnksm/power-assert-rs for Rust
https://github.com/haya14busa/vital-power-assert for Vim script

TODO: write about power assets in https://en.wikipedia.org/wiki/Assertion_(software_development)

Python или Java? Хм… а может Groovy?

На DOU новый холивар Что выбрать бывшему учёному — Python или Java?

Хочу оставить позицию младшего научного сотрудника и переквалифицироваться в разработчика. Всё высшее образование было профильным — информатика. Коммерческого опыта в программировании нет, только эксперименты и учебные проекты. В последнее время предпочитаю писать их на Python, для него есть хорошие научные библиотеки.
Цель — найти позицию разработчика, которая могла бы мне дать начальный опыт. В перспективе — вывести на более наукоёмкие позиции (анализ данных, машинное обучение, обработка естественных языков).
Город большого значения не имеет, особых требований по начальной зарплате нет — лишь бы хватало на съёмную квартиру и проживание.
Работу начну искать где-то с весны, поэтому остаётся время на подготовку. Осталось решить, в каком направлении мне развиваться.
Некоторые соображения (рынок я знаю плохо, поэтому можете смело поправлять):
1) По Java вакансий намного больше, чем по Python. Кроме того, можно официально подтвердить знания Java, сдав какой-нибудь начальный экзамен Oracle — это может привлечь внимание HR.
2) С другой стороны, в Java есть множество неизвестных мне корпоративных технологий и фреймворков, в которых можно надолго утонуть. В Python с этим проще — если я освою базовый Django (может, Flask, Bottle) и сделаю на них несколько личных проектов, то это должно покрыть начальные требования.
3) Java — это в основном аутсорс, Python — это в основном продуктовые компании (или у меня сложилось такое впечатление).
Что будет лучшим стартом, если мне хочется дорасти до профессиональной работы с анализом данных, прогнозированием, построением рекомендательных систем и т.п.?

Как и следовало ожидать разгорелся сильный холивар, но почему-то не упомянули Groovy — язык который как раз ииногда и называют помесью Питона и Джавы.
Я решил ответить:

Пока единственный известный мне настоящий специалист по Data Science поработавший в Германии на суперкомпьютере, работал таки на Java, и я вообще сомневаюсь как что-то действительно большее Hello world можно написать на Python.
Хотя, конечно, хорошие программисты могут писать на чём угодно.

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

И всё таки лучше не забывать что Питон обманчиво кажется простым: он довольно своебразен и уводит в свою вселеную.

Мне кажется, что пока лучше выбирать JVM, как платформу. Если не будет хватать возможностей Java то можно попробовать другие JVM языки: тот же JPython, Scala или Groovy.

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

В случае, если захочется большей выразительности, DSL или динамики то есть Groovy — великолепный язык программирования, обратно совместимый с Java и обладающий наверное всеми теми качествами за которые тут так сильно хвалят Питон.

На Groovy кстати есть даже всякий научный софт, например GroovyLab:

GroovyLab is a MATLAB-like scientific programming environment based on Groovy with extensive plotting support, default access to the best Java scientific libraries, user-friendly interface, easy installation of toolboxes, Computer Algebra support and many other features.

Вообщем, могу сказать точно что выбрав джаву не прогадаешь
joseph-ducreux-meme-disregard-python-acquire-java-080b2b


Не поленитесь, и почитайте ещё несколько очень важных моих статей для начинающих программистов, студентов и джуниоров.
Также не забудьте вступить в группу IT Juniors куда я пытаюсь собирать ссылки на другие полезные статьи для вас и анонсы курсов и интернатуры в компаниях.

toString() contract

Today I read great article of Fabian Kessler Java toString(): the Program Logic vs. Debug Dilemma.

In short, it is not obvious how to override method and what exactly means «string representation of object»:

Hrm. So there are mainly 2 uses:
String representation: toString() returns the object’s value «as string» as close as possible.
It is absolutely required to override toString(), and to do it in this way.

Debug information: the object’s values for the human.
For example IntelliJ IDEA’s default toString() template generates this kind.
It’s just nice to have.

JavaDoc says:

Returns a string representation of the object. In general, the
toString method returns a string that
«textually represents» this object. The result should
be a concise but informative representation that is easy for a
person to read.
It is recommended that all subclasses override this method.

Quotation from the «Effective Java» book:

One important decision you’ll have to make when implementing a toString
method is whether to specify the format of the return value in the documentation.
It is recommended that you do this for value classes, such as phone numbers or
matrices. The advantage of specifying the format is that it serves as a standard,
unambiguous, human-readable representation of the object. This representation
can be used for input and output and in persistent human-readable data objects,
such as XML documents. If you specify the format, it’s usually a good idea to pro-
vide a matching static factory or constructor so programmers can easily translate
back and forth between the object and its string representation. This approach is
taken by many value classes in the Java platform libraries, including BigInteger ,
BigDecimal , and most of the boxed primitive classes.

I found that most of code that I saw uses some unwritten «toString() contact». The contract mostly based on difference between Entity and Value objects.

1. «String typization» mechanism

The Delphi programming language has a great conception of Variant type. It is difficult to me to explain this in few words. It is like an universal container for the primitive types.

This is like a def keyword in Groovy: it mean any type. But any primitive type, not an basic Object.
And there is convention like a «Groovy Truth» how one primitive type should be converted to another.

Unfortunately Java hasn’t Variant type, so it uses String as it replacement. Hence, any primitive type you can convert to sting presentation: numbers, dates and boolean.
This is called StringlyTyped pattern and actually it makes code understanding painfully.

String typization

That’s why we should look on toString() as on data converter «as string».
And it should work only with Value classes and primitive datatypes wrappers, i.e. Integer, Boolean, Double, Date, Phone Numbers etc.

Important thing here is that this resulting string representation of value can be parsed verse to get an original value.

2. Serialization

In more common sense toString() it is a kind of serialization.
Even more, toString() can return JSON on CSV value.
But you should remember that deserialization is not granted by method contract.
That’s why you should use standard approach and implement Serializable interface.

But you still can use toString() as serialization for basic types that already contains written toString(), parse() and valueOf() methods.

3. Human readable representation of object

Another thing is when we need to show the object to a user. In this case it may be better to create another method called like a getDisplayName(), getTitle() or getCaption().

For example User class can contain getFullName() that return First Name and Second Name with space between them.

public class User {
   String firstName;
   String lastName;
   
   String getFullName() {
       return firstName + " " + lastName;
   }
}

Why it is better? First of all human readable names can be different and one string representation method may be not enough.

For example lets take a look on Facebook. In the private mail conversation between two users we can just write first name. At the public profile page we can display «First name + (nickname) Second name».

Also, usually this kind of display names can be localized. For example name of month or book title.

4. Log/Debug representation

In all other cases toString() used for logging or debug output. Just to make developer life easier.

The Groovy has a helpful @ToString annotation that generates this method in runtime.
For example class User can contain toString() method that return user login or email:

@ToString(includeNames = true, includes = 'email,firstName')
class User {
   String email
   String firstName
}

...

def user = new User(email: "admin@example.com", firstName: "Administrator")
assert user.toString() == "User(email:admin@example.com, firstName:Administrator)"

...
log.info("User ${user} logged in")

Here log.info() will call toString() method that is not good. I’m totally agree with Fabian and such method should be named toDebug() or dump(), but not toString().

Conclusion

Using this conventions may make your code better and safer.
I would be very thankful if you share conventions from your experience 🙂

«Grails — The search is over»

Grails это очень прогрессивный Rails’style веб фреймворк для Java.
На его сайте висит лозунг — «Grails — The search is over». Почему так пафосно?
Это поймут наверное только Java программисты.
Вот в .NET например выбирать особо не приходится. Microsoft дают почти стандартный стек технологий:

  • На чём программировать? Вот вам всемогущий C#.
  • Нужен MVC? Вот вам ASP.NET
  • База данных? Вот вам MS SQL Server

И так далее. Почти на любой чих у M$ найдётся супер технология. Только готовьтесь раскошеливаться.

В Java всё намного веселее. Из сотен библиотек и компонентов каждый раз ты начинаешь лепить свой велосипед.
И выбор становится реальной головной болью:

  • Java, Scala, Groovy?
  • Java EE? Glassfish, JBoss, WebLogic, Tomcat, Jetty?
  • EJB, JPA, Hibernate, jOOQ?
  • GWT, Vaadin, JSF?
  • Spring, FreeMarker, SiteMesh?
  • jUnit, TestNG, Mockito, Unitils, DBUnit?
  • Maven, Ant, Gradle?
  • java.util.logging, commons-logging, SLF4j, SLF4J

ААААААААААААААААААААААААААААААААААААААААААААААААА!!!!!!!!!!!!!!111

Хотя это очень хорошо что есть выбор. Но такое обилие выбора имеет два побочных эффекта:
Паралич — ты начинаешь откладывать на потом решение вопроса
Ты всё равно останешься недоволен выбором: «Блин, может лучше было взять GWT?»
Один профессор посвятил целую жизнь изучению проблем выбора.

В целом, как я могу судить по количеству вакансий которые видел, для большинства веб проектов среднего масштаба в Java постепенно приходят к такому стеку: Java, Spring MVC, SiteMesh, jUnit, Mockito, Selenium, Maven, Hibernate, MySQL, Tomcat. В принципе вполне вменяемый стек, хоть и не совсем совместимый в JavaEE.
Следующая проблема это собрать весь этот конструктор. Тут тоже много сюрпризов: от несовместимости версий до дублирующегося функционала.
Вот например Алексей Резчиков создавал простое приложение для TODO списка:

У этого приложения POM файл получился почти на 800 строк. В принципе не так уж и много — это всё же многословный XML. Но это TODO приложение, блин!

Самое интересное что в конце концов у всех проектов получается примерно одинаковая структура и набор библиотек в основе.
Когда код разрастается и программисты начинают теряться в проекте, тогда приходят к единым соглашениям о том что и как писать и куда класть.
Например, «давайте контроллеры будем класть в папочку controller а бизнес сущности (Entity) или доменные объекты в папочку domain.
Во первых сразу знаешь что где искать, а во вторых теперь можно не наследовать каждый класс от какого-то абстрактного контроллера или вешать ему аннотацию — наш фрейморк итак уже будет знать что это контроллер и как себя с ним вести.
Явная спецификация конфигурации требуется только в нестандартных случаях.
Такой подход назвали Convention over configuration (Cоглашения по конфигурации).

Известным этот подход стал после успешного применения в веб фреймворке Ruby on Rails.
Успешным этот фреймворк стал также благодаря динамическим возможностям языка Руби которые казались какой-то магией.
Многие из этих возможностей Руби попали в язык программирования Groovy — это такой динамический диалект Java который учится за 15 минут.
Груви обратно совместим с Явой, просто добавляя в неё возможности динамического и функционального программирования. Эти возможности позволяют очень многократно сократить количество кода. Иной раз и вовсе как будто псевдокод читаешь.

Так вот, завистливые джависты скопировали идеи из Ruby on Rails, и создали Groovy on Rails. Но им пригрозили судом за использование Rails в качестве торговой марки, и тогда его переименовали в Grails. Так получилось даже лучше — Grail, в переводе с английского, это Священный Грааль.
Внутри него лежат уже сконфигурированные Spring MVC и Hibernate и много чего другого, и всё это под соусом Груви.

Не изобретайте велосипеды, попробуйте Grails.