Since about 4 months I’ve been using this site to keep my Crypto assets and I really like the User experience (UX) and also the design, both of the website and their Android / Iphone application. YouHodler is a DeFi platform where you can store your Crypto assets and get a yearly percentage interest, just as other known websites BlockFi and Nexus. With the particularity, that YouHodler let’s you bet on UP / Down price changes and increase your assets (To be clear: That if your technical analysis is good and it goes in the direction you estimate)
It flows, uses very modern web techniques, that are not perfect since many times you need to refresh the whole thing until it works but it’s visually appealing and also simple to use. But there is something that called my attention and I wanted to write about it here, with some thoughts, because I’m sure that I’m not the only one that detected this.
This is not a critic to the site, but more my personal view, about how the UX and interaction design can influence risk and sometimes put the user in an undesired position just because he wanted to take a fast action to increase his assets.

Here is an enumeration of the defaults I’m talking about:

1. MultiHodl price bets take always your full amount of the Crypto choosed

Let’s say I have 48.5 UNI and I choose to make an UP bet this is what happens as default

Only on Ipad / Iphone when you click over the amount to bet it offers a quick 20% or 50% selection.
That’s fine and much better than Android or the Web version that come with the full amount and you have to update it by hand. Are you in a rush since you loose momentum and click fast, well it’s your risk, you ‘ve just put all your Crypto at stake:

Now what happens if the default Price Down Limit (PDL) is hit?
As default is 11x or 13x that gives you about 7 or 8% PDL: If it suddenly goes down that amount you have 0 left. Is all gone. That’s what is a margin call about. When the down margin call is hit, in case of an UP bet, the amount you use as collateral is used to repay the Loan.

This is a real operation happening, and YouHodler is buying or selling assets, in a chain of loans so this is what is all about.

2. Longer term loans called Turbocharged

With another option called Turbocharged loans happens something similar, let’s say I choose to Turbocharge my 0.010045 Bitcoin:

Very similar situation. As default full amount is selected. As default the highest risk level is selected.
A -5% price down limit can “maybe” work after a very low moment, like in March 2020, or even in whole period till November 2020 since it was mostly in a bullish scheme going up all the time. But it’s not the normal situation, and everything that growths has pullbacks. This pullbacks are usually much higher than 5% and it maybe go 15 or even 20% down in a single day. That happens with everything if you see the stock marketing, but specially with Crypto. Now let’s check what happened in Black Friday as a first example:

Now that is a 12% pullback in less than 24 hrs. So imagine that even if we start a Turbocharged loan on the green arrow, we will be very happy since it goes up in the next hours, only to wake up the next day with the Price Down Limit call (PDL).
And what happens with a Turbocharged loan when the PDL is hit?
Basically you get part of the money back in EUR (If you choose EUR as borrowed ticker) but the rest of your crypto is gone forever. So be aware that when choosing a -5% PDL you are taking an unusually high risk that can backfire in any moment, even if at the beginning is going up. To make a more visual example with my own bad technical analysis and failure, this was done with 2.5 ETH in January 22 aprox. in a moment where all Crypto was going down at least 10%:

Please notice that this is my fault since I forgot to change the plan to a 2 Month -25% PDL. But is also partly the unusual YouHodler settings, that take the full amounts and the more risky options as their default choice.
Now the question is: Is this deliberately made? Or is just because the UX was designed like this?

Ultimately it is the user choice to select how much risk he is going to take. That is clear and I’m not complaining about it. In many cases I won, other I loosed, is all risk investment money that I can afford to loose and I won’t cry about it, not even a minute. But in this case, I think having such a great UX designer on board they could have done much better.
If you are DeFi company that is willing to make your users HODL their assets, then you don’t select the full amounts with the higher risiko as default. At least make this an user choice (More on that later)

3. Not transparent reporting options for MultiHodl bets

If you use MultiHODL for doing bets regularly, there is not any option to download a full report of your wins/looses. You have to make it yourself, this is for example my own online Excel for this:

As you can see, if you do a good technical analysis, and you are strong enough to hold and get out only in a win position there is some money to be made. And I could recover my 1.5 ETH in 2 months if I wanted to.
But that’s not the point. My idea to make this platform better is to add in the settings a Risk profile option:

◎ High risk, as default -5% PDL, x11 MultiHodl risk. Full crypto amount
◎ Low risk profile, as default -25% PDL, x6 MultiHodl risk. Uses 20% of your selected crypto

But as you see is not preselected the High risk option how YouHodler is doing it now is like this:

🔘 High risk
◎ Low risk

What I really expect as a user is that there is a setting or similar to select the default risk I’m going to take. Maybe not preselected, just let the user decide.
There is a reason there are laws in place at least in the EU, so you cannot preselect the join newsletter when a user registers:

☑ Join our newsletter

You won’t see something alike in a website. At least not in an European website since the protection laws clearly forbid this and there is high fine to pay if you do it.
I know that the decentralized finance is a different situation and I’m not saying that what YouHodler is doing is inherently bad or wrong. It’s just my opinion that it should be a better option to do it.
Or at least like I mentioned before, to let the user select his risk profile in settings so the defaults are treated differently for each personal setting.

This will be a very smart choice to make the users more secure about using the platform and also a way to make the YouHodlr users hold more assets instead of loosing them in wild rides with the highest risk in a volatile market where you should be better a good technical analyst instead of a wild cowboy.
I hold only a part of my assets in YouHodler and others are in my private wallet. Part of them are also in my girlfriend BlockFi account, I think is a good idea, not to put all eggs in one basket since in this game is all about risk.

That said I’m fond of using YouHodler even with the issues I mentioned. I think it has a lot of potential and is very well designed in many aspects, their UI is consistent and the user experience well designed, something that being a backend website developer I can confirm.
Any reaction or explanation for my claims here will be also published, and of course ideas or comments, are always welcome.

Since 3 months I’m involved in a project to mount an ecommerce in PHP/ Symfony 4. My client makes beautiful objects for the home interior using concrete as her main material.

The goal is to make something minimalist, since in my opinion, most of her creations have this minimal feeling. A simple shape, mostly an unique color, except on some pieces where red is used are the characteristics of most of her creations.

After an initial research on existing ecommerce projects like Magento and other Symfony based, I choosed Sylius because of it’s straigh-forward installation and customization possibilities.
So far me and my client is happy with the result, we will keep adding ideas and measure what is the impact on the site on the next months. I’ve always said that is not easy to sell in the internet. Even if your product is good, a considerable amount of time needs to be spent just on planning how to drive traffic to your site, SEO and most important Content.
Because content at the end is the king. And only you will appear in the search results and with some luck, be linked from external websites, if you have good and quality content that satisfies what the users come to find in your website.

That said I hope we started in the right path, like every ongoing project, there is long road ahead.
If you like interior design and handmade objects go ahead and check it out.

When I first bought one Good Display 2.7 inch epaper with a FocalTech touch panel, it was a curiosity that I never though it will call my attention, and will end up in one of the wood boxes under my desk. This is the short story of how this small piece of technology really caught my attention and evolved to a full pledged ESP-IDF component that will enable you to make simple UX on epaper for your Firmware.

The cool thing about touch is that wiring 3 cables more, you are able to read X and Y coordinates plus the touch event, and react in the same epaper. Kind of having a small UX playground that enables you to make buttons and a free canvas to draw or take decisions.
It took me one week of research to add the ESP-IDF I2C library, which is based on the work of Strange-V, a developer that did the FT6X36 for the Arduino-ESP32-framework.

My work was to take this as a base and do the I2C communication using the ESP-IDF I2C peripheral documentation as a model. One of the things I love in this framework is that is not a given to do I2C (Wire in Arduino) or SPI. All needs to be low-level instantiated, which makes it a bit harder when you are accustomed to the easy-peasy approach of Arduino, but also unleashes the whole low-level potential of the ESP-IDF.
Don’t take me wrong, I like both frameworks, and ultimately the mission is that it works good together and you achieve in C++ or C an stable Firmware.
So after achieving this first step in the Fork that I renamed to FT6X36-IDF, also to connect to I2C and read what is coming from the FocalTech touch panel, the next immediate goal was to inject this class into my existing epaper component for IDF. The CalEPD component. This is how this new class was inserted:

The touch panel working together with the epaper class had a very obvious pitfall: My epaper component, same as GxEPD, extends popular Adafruit GFX library to let you use graphics and fonts. This also makes the epaper rotation aware, since we extend the original drawPixel, and make it our own for every different epaper model:

void Gdew027w3T::drawPixel(int16_t x, int16_t y, uint16_t color) {
  if ((x < 0) || (x >= width()) || (y < 0) || (y >= height())) return;

  // check rotation, move pixel around if necessary
  switch (getRotation())
  {
    case 1:
      swap(x, y);
      x = GDEW027W3_WIDTH - x - 1;
      break;
    case 2:
      x = GDEW027W3_WIDTH - x - 1;
      y = GDEW027W3_HEIGHT - y - 1;
      break;
    case 3:
      swap(x, y);
      y = GDEW027W3_HEIGHT - y - 1;
      break;
  }
  uint16_t i = x / 8 + y * GDEW027W3_WIDTH / 8;
  if (color) {
    _buffer[i] = (_buffer[i] & (0xFF ^ (1 << (7 - x % 8))));
    } else {
    _buffer[i] = (_buffer[i] | (1 << (7 - x % 8)));
    }
}

But what happens if we call setRotation(1) and rotate our display 90° to the right (To make it clear, we rotate our code, the epaper knows nothing and just receives a pixel buffer)
The display rotates, and if we sent a pixel to the X:1 Y:1 corner, it will be effectively drawn 90° rotated. But the touch will be still giving our old X and Y data. The touch is a completely hardware detached panel, in the top of the epaper, that again knows nothing about what we are doing.’
So here is the catch, let’s allow this new touch component to be injected in the epaper, just as we inject the SPI IO (Input /Output) class, that is really I for Good Display since the SPI is only a slave that does not communicate with the master, expect of a Busy line. Another epapers, such as the PlasticLogic line, also send temperature readings using the same SPI line so they are IO for real.
This is how it looks in the C++ class Gdew027w3T that is my clon of the non-touch class:

// Constructor of the Gdew027w3T class:
Gdew027w3T::Gdew027w3T(EpdSpi& dio, FT6X36& ts): 
  Adafruit_GFX(GDEW027W3_WIDTH, GDEW027W3_HEIGHT),
  Epd(GDEW027W3_WIDTH, GDEW027W3_HEIGHT), IO(dio), Touch(ts)
{
  printf("Gdew027w3T() %d*%d\n", GDEW027W3_WIDTH, GDEW027W3_HEIGHT);  
}

// Sample of how this is injected in main.cpp
#include "FT6X36.h"
#include <gdew027w3T.h>

// INTGPIO is touch interrupt, goes low when it detects a touch, which coordinates are read by I2C
FT6X36 ts(CONFIG_TOUCH_INT);
EpdSpi io;
Gdew027w3T display(io, ts);

So that’s it now we can inject the FT6X36 into the epaper class itself. This is the perfect moment to think what methods we can add to Gdew027w3T class to make the rotation touch aware:

/**
 * Helper method to set both epaper and touch rotation
 */
void Gdew027w3T::displayRotation(uint8_t rotation) {
  if (rotation>3) {
    printf("INVALID rotation value (valid: 0 to 3, got %d) rotation*90\n",rotation);
    return;
  }
  setRotation(rotation);
  Touch.setRotation(rotation);
}

Perfect. Now if we call display.displayRotation(1) our display will rotate and also signalize the Touch that we’ve rotated so we can recalculate the X and Y rotation in the touch panel.
Note that the Adafuit method setRotate is still there, since I didn’t wanted to extend it, so if we call setRotate then the same as before will happen. I just wanted to demonstrate how powerful is to build on top of C++ object oriented classes.
I hope you can get one of this touch displays, the only low-down is that you need to get one 6 flat adapters, and to check the PDF documentation on Good Display to wire this 3 cables to the ESP32.

Parts list:

One 2.7 inch b/w epaper with touch – 15 u$

One epaper SPI adapter (24 flat cable to SPI Pins) please be aware that this two connectors work independently of each other and both need a common ground and 3.3 volts to work.

That’s all you need. The schematic is the same as any other SPI epaper with this I2C on top, I can provide samples if needed, here my list of how I wired this for this example:

#
# Mosi and Clock should be set for any epaper
#
CONFIG_EINK_SPI_MOSI=23
CONFIG_EINK_SPI_CLK=18
CONFIG_EINK_SPI_CS=5
CONFIG_EINK_DC=16
CONFIG_EINK_RST=4
CONFIG_EINK_BUSY=15

#
# The FT6X36 touch chip needs an I2C port and one input GPIO
#
CONFIG_TOUCH_SDA=21
CONFIG_TOUCH_SDL=22
CONFIG_TOUCH_INT=17
CONFIG_I2C_MASTER_FREQUENCY=200000

To browse a full implementation example you can just checkout the following repository:

https://github.com/martinberlin/cale-idf this touch example you can find in main/demos/demo-touch-epd-implemented.cpp (Make sure to select this target in CMakeLists.txt)

If you like this and it works for you I will be really happy to get a ★ Star in the repository.
And if you use it for a real life project I will appreciate a small donation following the links on the github repository. As I mention sometimes:

Open source is for free. But the developer’s time has value. So I think is fair sometimes to ask for a donation and also to support another developers donating to them when we use their components.