Lead Engineer at PAX Labs, we just open-sourced some Java utilities i wrote in the early days building service oriented architecture on dropwizard: https://github.com/PaxLabs/java-utils
A few things in there:
* `HibernateQuery` - wrapper around hibernate jpa implementation, because using the jpa criteria api is verbose as hell (seriously, even for java). Coming from having written Django, I wanted the ease of using Querysets in java
* Makemigrations - this seemed to be a missing hole in the java ecosystem. Our contractors were hand-writing sql migrations and using some framework that just ran them. Liquibase exists for managing migrations, hibernate can generate the schemas. This library is a dropwizard command to generate yml to migrate the old schema to the new one.
It's not a tradeoff. The reason we like quality code is it saves time in the long run by being clear, easy to change, less error-prone, etc. If you expect to be employed in 6 months, you should be refactoring and putting care into the quality of your code. It's hard at first, but I'm at a point where I'm the most productive engineer and I work the least amount of hours - because my code is there to help me, not hurt me.
I've been working on a similar project in my spare time to create tools for interactive technical blogs [1]. It's funny, in the past day I've seen two projects that I would say have the same goals as me, idyll being one of them.
What are the possibilities around contributing to idyll? Building on top of it? Is it as simple as writing my own components?
I'm specifically interested in uis to define data structures. One of the more annoying things I found working with d3 to create graphs (as in graph theory) was defining the graphs procedurally, so I built a ui to define graphs graphically.
I'd love to talk more about possible ways to collaborate. Adding components that help interface with other libraries are a great way to contribute. For example, the recent integration with Apparatus [1].
Feel free to jump in our chat [2] or shoot me an email [3] and we can talk more.
Absolutely. We have several front end layers, then nested service layers and then nested repo layers, all get mocked depending on the level of object we are testing. We then have separate integration tests that test the repo against an actual database. We design the integration tests so they are largely data independent (we load the data we test rather than just mock data).
Without ever having seen one? Or with having seen pictures of one?
It's true though that we can generalise from descriptions and recognise the real thing from those. If you describe an elephant as a big grey animal with big ears and a trunk they can use to grab stuff, then an adult (not a 2 year old I suspect) seeing one for the first time, will recognise it from that description.
When we see a cartoonish drawing of one, we can still distill the defining characteristics from it and use it to create a description or recognise the real thing. We can recognise a very crude childish drawing of one by looking for these characteristics. We have a lot of additional knowledge that influences our image recognition, and having a big toolbox of general recognition of tons of different objects, we don't really need to train to recognise new objects anymore, because we will distill its identifying characteristics the first time we see it.
Some pattern recognition seems to be innate, for example chicks just hours old can recognize the shadow of a flying bird as either harmless (long neck short tail) or a predator (short neck long tail).
So, while this pattern in particular doesn't apply to humans (it really doesn't?), many animals have ready-to-use pattern recognition when they are just hours or days old.
Those are instincts bred by evolutionary because they're vital for survival. Recognising an elephant is not the same thing for us. Instead, we get a generic toolbox for quickly learning to recognise very different objects, from animals to machines to abstract shapes. We're not born being able to recognise them, but we can pick them up very quickly from even rough descriptions.
True, but if we are into exploring the possibilities of what can be done with artificial neural networks, I see no reason to limit our models to human brains only.
A few things in there:
* `HibernateQuery` - wrapper around hibernate jpa implementation, because using the jpa criteria api is verbose as hell (seriously, even for java). Coming from having written Django, I wanted the ease of using Querysets in java
* Makemigrations - this seemed to be a missing hole in the java ecosystem. Our contractors were hand-writing sql migrations and using some framework that just ran them. Liquibase exists for managing migrations, hibernate can generate the schemas. This library is a dropwizard command to generate yml to migrate the old schema to the new one.
* generic pagination bundle