We all know that we should test our code. Flutter makes this really easy with all of testing frameworks that are coming bundled with it. You can write unit tests, widget tests and UI test.
Testing callbacks are particularly tiring. I bet you seen code like this many times, even more, if you are testing your widgets, I’m almost sure you have written this kind of code.
At the time of writing it is already nine months since I’ve started my adventure with mobile app development and ReactNative in particular.
Before that I’ve wrote an simple Android “stopwatch with reporting over email” app for Megaron. I’ve also wrote full blown iOS app in Swift for my startup, that didn’t went live, although the app was decent! (Side note: as it usually is with tech startups run by tech people we didn’t found a market for it).
As you already know, HabitChallenge is not really my “first” mobile app, but it is first that went live and is actually used by plenty of people around the world.
The story starts back in July 2016, when I’ve broke my tibia bone… That means at least 3 months of lying down in the bed… no walking (at least not without crutches), no running, no going out… My first idea (actually second one, first was not to bother about it and live my normal life… how foolish I was) was “Let’s use this time productively and make as much as possible from it!”. That’s how I started thinking about my first publicly available mobile app.
Why mobile app? There were plenty of reasons:
OK, so it would be an mobile app… which platform? iOS or Android? Of course the answer is “both”. Since I was already familiar with development for both of them I know what to expect… and didn’t wanted to play with XML layout files for Android and Storyboard or XIB (which internally are also XML) for iOS; writing UI code manually was also not an option. Lucky on ClojureD conference I’ve heard about ReactNative and that was my weapon of choice 😉
I’ve already said why and how… but “what” is still an open question. It shouldn’t be something big, nor buyer-seller type of app. It should some kind of utility app… or productivity…
Back then I was using HabitLoop to track my habits. It was not the nicest looking app, but it is open sourced has decent set of features and only available on Android. “Yeah! Let’s write yet another habit tracking app!” was my thought… “But it should have some ‘twist’, so that it won’t be a simple clone…”.
At that point I’ve started listing features and picking what will be included in first release (aka. MVP). In about two days I had listed everything, write it down, decided and commit for it.
The first version of HabitChallenge app had:
Estimated time: 4 weeks, actual time spend: 9 weeks. The first version of HabitChallenge was available for install on AppStore and Google Play on 13th of October 2016.
Just recently HabitChallenge was installed over 10 000 times on Google Play (it took about 5 months to get there). It is used all over the world (although it only supports only Polish and English) and the “twist”, the “killer feature” is still not implemented yet… and I’m still working it 😉
If you manage to read so far… that’s the end 🙂 Please give HabitChallenge a try and if you like it give it 5 starts on Google Play and AppStore 🙂
If you ever would like to run multiple WordPress installations on one NGINX server and sharing one domain name. Also you would like to have nice urls like /%catetgory%/%postnname%/ on both of them. You better do not do it in the root configuration block like this:
location / { try_files $uri $uri/ /index.php?$args /another-nestetd-wp/index.php?$args; }
Of course this will work… but as a side effect posts from /another-nested-wp/ will be leaking into main blog RSS feed. Trust me 🙂 I’ve only found out about this thanks to JVM Bloggers and my colleagues asking me wether my site was hacked 😀
Some things one need to learn the hard way.
Nevertheless, proper NGNIX, configuration should be done for /another-nested-wp/ (not root node):
location /another-nested-wp/ { try_files $uri $uri/ /another-nested-wp/index.php?$args; }
This way both blogs shouldn’t interfere with each other. And both can use nice urls 😉
One again many thanks to the community from JVM Bloggers for quick information about this (self)hack 😉
As always after the Gerrit User Summit, a Gerrit hackathon took place.
This time it was a five days event (9-11 November 2015), where members of the Gerrit community could work together, fully focused on making Gerrit a better software.
2015 edition gathered 15 participants from various companies like Google, SAP, Sony Mobile, Qualcomm, OpenStack, Axis Communications, Gerritforge and of course CollabNet.
Hackathons are really intensive periods of time for Gerrit project: over 400 patches were merged, three releases (2.11.5 and two release candidates of 2.12) were performed, countless number of open changes and patchsets were pushed for review.
This blog post summarizes work done during that period of time, showcasing new features upcomming in 2.13 and 3.0 release.
If you are responsible for running mission critical software for your organization, you must know how important monitoring and metrics are. How important it is to get fine grained information about the application performance. It is simply not enough to know whether it is up and running but also what is the overall shape of it.
This kind of information is especially critical when users start complaining “Gerrit is slow”.
From time to time such complaints arrive also to our team in Potsdam, then we use Splunk to analyze the load based on Gerrit logs and give our recommendations how to tweak Gerrit. Based on such cases our Gerrit Performance Cheatsheet was composed meuh7iu.
Starting from Gerrit 2.13 we will have a new tool in our toolbox! Internal Gerrit metrics!
DropWizard Metrics library is used as internal engine. Gerrit exposes over 1300 metrics about crucial internals e.g. http server response time, git receive pack, git counting objects, cache sizes, etc….
What is even more awesome, plugins can report their own metrics using the core API. This way replication plugin for 2.13 will report time taken to replicate repository data to various locations.
One thing is to collect metrics, the other is to store them. For this purpose three new plugins were created: metrics-reporter-elasticsearch, metrics-reporter-graphite and metrics-reporter-jmx. This gives possibility to plug Gerrit in into already existing infrastructure.
There are two ways in Gerrit how one can be notified about git operation related events. One is via event mechanism and another via Gerrit hooks. Both provide almost identical functionality making deciding on implementing one of them harder.
During our hackathon work was started to extract hooks mechanism into plugins that would listen to core Gerrit events.
This work is still ongoing, but once it gets finished one that want to run server side hooks must install the Gerrit hook plugin.
You may be wondering what is the gwtorm. This is a library written for Gerrit project to access relational databases. It is a lightweight method of connecting your Java application to multiple different DB backends. Initially it was meant to be used only by GWT based applications (hence gwt prefix in its name), but currently it can be used by any Java application.
Why to use gwtorm in plugin? Well if you don’t want to modify Gerrit schema (which is highly discouraged) to store your plugin data and want to support many SQL dialects out of the box, gwtorm is the way to go.
The first plugin that will use this library is gerrit-ci-plugin.
Gerrit releases don’t happen too often. Some time we had to wait long months (and over 1000 commits) to get new stable version of Gerrit. Usually just before the hackathon a release candidate of new stable version is cut from the master branch.
During this year’s hackathon we got three releases! One was a service release for 2.11 (updated release notes) branch containing fixes for javascript clipboard, styling, commit validation error handling.
Apart from service release two release candidates were published for Gerrit 2.12.
Gerrit 2.12 changes how patches are submitted to the repository after code review. In all previous versions there was so called “merge queue” which was responsible for submitting patches in the right order. If particular change was submitted but its ancestors were still under review it ended up in a special state “submitted, merge pending”.
In 2.12 changes arranged in a branch (one change depending on the other) can be submitted at once by single click on the submit button on the topmost change.
Additionally new feature called ‘submit whole topic’ was added. It enables submission of changes that share the same topic. This can be done across multiple projects and branches.
One thing that struck us when this feature was presented during Gerrit User Summit was change in the semantic of Gerrit ‘topic’. Before 2.12 topics were only metadata that could have been freely added and removed. Plus there was possibility to search for changes that share the same topic. Starting from 2.12 setting a topic on changes will change how they are submitted. In some rare cases one can submit changes of others or block them because of a change not visible to all is still waiting for being reviewed.
To make submitting more verbose during the transition period, a submit dialog was proposed. It pops up after clicking on the submit button only when changes from the same topic would be submitted. It presents the list of changes submitted in a topic and without it, so that the submitter can choose whether to just merge the change in question or all changes of the same topic.
Some time ago a Diffy build bot was introduced to verify changes pushed to gerrit-review.googlesource.com, but after some time it become unreliable, often was simply not verifying because it was not running.
Now there is new verifier in the picture. Based on proven gerrit-trigger-plugin custom REST API pooling strategy and Jenkins tandem. It is kindly hosted by the GerritForge. Long life to new GerritForge CI bot!
NoteDB is the defining feature of Gerrit 3.0. It will replace “conventional” database system and store everything inside git repositories. All the data that is currently stored in SQL DB will be moved to git repositories. Review related information will be stored in the particular repository using git-notes and special refs. User data will be moved to dedicated repository.
During the hackathon further steps into achieving the goal of removing the dependency from SQL DB were performed, some integration tests were fixed plus NoteDB tests were enabled as a part of verification job.
Last but not least, the new Polymer based WEB UI for Gerrit was initially announced and integrated into Gerrit’s build process.
During the Gerrit User Summit, Google has presented the draft of a new Gerrit WEB UI. This time it is written using Polymer framework, which is a new JavaScript UI design framework from Google.
The new WEB UI will be fully written in JavaScript, making it easier for UI/UX designers to modify and faster to develop and compile.
As I mentioned before, during hackathon PolyGerrit project was integrated into standard Gerrit build system. It requires teaching Buck how to deal with javascript and its dependencies.
Next is the Berlin Gerrit Hackathon in 2016. We’ve open a poll to gather input from the community about preferable date between 22nd of February and 25th of March 2016. Please participate if you would like to join us and hack Gerrit in Berlin 🙂
Gerrit submit rule is a set of conditions that needs to be fulfilled before change can be submitter (read merged) to given branch. By default there are only two simple conditions:
First one means that change don’t break the build (or project integrity). This step can (and it should) be automated using, a continuous integration system like (jenkins with gerrit trigger plugin). Automation here will save tons of men hours spent on reviewing code that doesn’t compile and/or break unit/integration/system tests.
Second one (Core Review +2) means that somebody from the team spent some time on reviewing and understanding the change. And this particular person didn’t found issues in it and thinks that this change is ready for production.
This set of rules seams to be reasonable and will be sufficient for “most” of the projects. But it has some flows, indirectly build in.
First of all there is no condition on the person that is giving the CR+2. In this case, change author can submit his own change, because there is no condition that would block him from doing so.
Also if you would like to enforce more strict review rules for given project. eg. at least two CR+2 are required to submit a change. You will probably end up with ‘internal convention’ not something that can be enforced automatically by Gerrit.
Of course, one can say that those two cases are exotic. Yes, in a way they are. But my point here is that default Gerrit submit rules are OK for (let say) 90% of projects. Projects that fallow Android OpenSource Project review principles (they can even don’t know that they fallow them ;)).
What is with rest 10%?
No, they are not forgotten by Gerrit… but they have a bit harder live at the beginning.
Why it is harder? Because of Prolog.
Gerrit gives you a tool for defining your own Submit Rules per project. But the entry point is (I would personally say) high.
To define your own Submit Rules one need to learn Prolog programming language, then understood Gerrit Prolog API and finally define such custom Submit Rules per each project in refes/meta/config branch.
This is awesome! Show me a tool that have such flexibility build in, ready to use … and it is free? Yes, entry level is high but, come on, this is one time investment and you are set for (almost) a live time… 😉
But maybe we could do something better here? Maybe we are missing something here… maybe we are not looking abstract enough.
Let me compare code review process to standard build process. In both cases you have some steps that need to be accomplished before you move to next mile stone. In build first of all source code files need to be compiled, same goes for test source files in next step. After that tests are run, and when they pass successfully, project can be packaged and put into production.
Same goes for the review process. First of all change need to be verified (compiled and tested) then team members are looking on code and if they found issues with it, change must be reworked. If not, it can be “packaged” to “production” I mean, merged to branch.
If we use such approach, then maybe instead of writing code for review rules, we could have a configuration file. Why not put the configuration and convention over Prolog code?
Provided that we would have such configuration syntax in place, then we could define set of rules that will verify the configuration file. Then wring UI for generating such config file shouldn’t be so hard (compared to generating Prolog code).
What if…
OK, lets finish with those “what if’s” because there is noting to wishful thinking. Why? Because we already implemented such ‘configuration over Prolog code’ approach in CollabNet. This is what we called Quality Gate wizard.
It contains two key parts:
More information about Quality Gates can be found in our blog posts 1 2 3