“Beh… su cosa stavo lavorando???”

Il prezzo del cambio di contesto (context-switching) si paga sia in termini di tempo che di fatica mentale.

Vi è mai capitato di rivolgervi ad una persona mentre questa sta lavorando, magari semplicemente per chiedere un favore, e vedere che questa persona vi risponde in modo seccato apparentemente senza nessun motivo? A me sì. E ora vi spiego perché accade.

Per un lavoro che richiede concentrazione, le distrazioni e il cambio di contesto rappresentano un costo elevato in termini di tempo e fatica mentale. Prendiamo ad esempio il lavoro dello sviluppatore software: progettare e scrivere software è uno di quei lavori che richiede di immagazzinare molte informazioni nella testa tutte allo stesso momento (le specifiche del task a cui stai lavorando, i nomi delle variabili, le strutture dati da utilizzare, le API da invocare, i nomi delle funzioni che hai già scritto e che ti possono tornare utili…). Sono tutte informazioni che vengono tenute in memoria e vengono usate solo fin tanto che lavoriamo su quel task; una volta terminato il task, vengono “dimenticate” per lasciare lo spazio a quello che dovremo immagazzinare per il task successivo. Ora, supponiamo di distrarre un programmatore mentre sta lavorando ad particolare un task, portando la sua attenzione altrove, ad esempio perché gli chiediamo informazioni su un altro task su cui ha lavorato il giorno prima: lui sarà costretto a svuotare la mente per passare al nuovo contesto (la nostra richiesta di informazioni) e ragionare su questo. Appena finito, potrà tornare al suo lavoro, ma non immediatamente: prima dovrà raccogliere di nuovo le idee e le informazioni necessarie.

A seconda della tipologia e difficoltà del task, questa operazione può richiedere più o meno tempo e fatica. Se ripetuto più volte al giorno può causare una forte fatica mentale e causare nella “vittima” la sensazione frustante di non essere riuscito a portare a termine quello che doveva.

Quindi il prezzo del cambio di contesto si paga sia in termini di tempo che di fatica mentale (dalla quale deriva lo stress e lo stato di alterazione).

La soluzione? Cercare di limitare il più possibile queste situazioni. Se siete il lavoratore in questione, spiegate alle persone vicino a voi (i vostri colleghi ad esempio) che state lavorando e avete bisogno di concentrarvi, e di rimandare di qualche ora tutto quello che non è strettamente urgente (meglio: condividete con loro questo post!). L’uso della messaggistica asincrona (e-mail, WhatsApp, Telegram, Slack…) è utile in questi casi: se quello che va comunicato è urgente (ma veramente urgente!), lo si dice a voce, per tutto il resto si può mandare un messaggio o una mail e sarà il destinatario a decidere quando è il momento più opportuno per “distrarsi” e leggere i messaggi.

Lascio a voi decidere chi ricade nella categoria del “lavoratore” e chi nella categoria dei “rompiscatole”… E ricordatevi che, a volte, la stessa persona può ricoprire entrambi i ruoli! 😜

Fonte: l’esperienza personale, e questo articolo: https://www.petrikainulainen.net/software-development/processes/the-cost-of-context-switching/

Android Studio Logo

New features

Android Studio 2.3 has finally been released in the Stable Channel. There are many improvements compared to version 2.2, including:

  • Instant run: now there are two different icons, one for restart the app and another one for apply changes without restart. Screen Shot 2017-03-02 at 9.12.10 AM.png
  • Build cache: it’s used to have faster clean builds by caching exploded AARs and pre-dexed external libraries.
  • App Links Assistant (Tools → App Link Assistant): it allows you to create new intent filters for your URLs, declare your app’s website association through a Digital Asset Links file, and test your Android App Links support.
  • Support to WebP lossless image format: the WebP format is . Android Studio 2.3 has a new wizard that converts any non-launcher PNG file to WebP (up to 25% smaller than a PNG) and WebP back to PNG.
  • Constraint Layout with Chains and Ratios: this new version of Android Studio includes the stable release of ConstraintLayout. You can now chain two or more Android views bi-directionally together to form a group on one dimension (helpful when you want to place two views close together but want to spread them across empty space).

Problems and issues

Migration from Android Studio 2.2 to Android Studio 2.3 may not be completely painless.

This is a list of things that you may need to check to have everything working correctly.

  • In your root build.gradle file the gradle version should be updated to 2.3.0:

    classpath ‘com.android.tools.build:gradle:2.3.0’

  • The gradle distribution should be updated to version 3.3, so check for the following line in file gradle/wrapper/gradle-wrapper.properties:

    distributionUrl=https://services.gradle.org/distributions/gradle-3.3-all.zip

  • If you are using Kotlin, update both the Android Studio plugin and the dependency in your build.gradle to version 1.1.0

  • If you use annotation processors (like ButterKnife for example):

    • remove the following line:

      apply plugin: ‘android-apt’

    • change all occurrences of “apt” to “annotationProcessor”:

      compile ‘com.jakewharton:butterknife:8.4.0’

      annotationProcessor ‘com.jakewharton:butterknife-compiler:8.4.0’

You can find a complete list of improvements in the original blog post: https://android-developers.googleblog.com/2017/03/android-studio-2-3.html

Android framework provides no support for creating a TextView that can fit its content to its size.

There are some libraries out there that try to solve this problem, like:

But no one of them seems to work in every situation. Looking into stackoverflow I’ve come to this post which seems to hold the best working answer that I’ve tried.

Except when I’ve tried to use it when textAllCaps=”true”. The solution to this issue has already been reported in one of the comments. So I put up all togheter, and the result is the following AutoResizeTextView implementation:

Oggi si è tenuto al FabLab di Padova un Workshop sull’Internet of Things, durante il quale ho avuto il piacere di anticipare l’intervento di Intel con un intervento dal titolo #Google, #Android, #IoT.

Durante questo intervento ho fornito agli attendenti una panoramica sui servizi che Google mette a disposizione per l’universo dell’Internet of Things e mostrato come è possibile far comunicare una app Android con una scheda Arduino, sia a corto raggio tramite Bluetooth che da remoto appoggiandosi su un server Firebase.

Le slide sono liberamente consultabili a questo indirizzo.

Di seguito i riferimenti ai servizi, prodotti e librerie citati nell’intervento:

Grazie a OfficineDigitali ZIP per aver ospitato il mio intervento!

When you run your Android tests (like espresso tests), you may want to be able to force the locale of your device to some specific value at runtime (during test execution). This could be really helpful if you want to test some features of your app against multiple locales.

You can do this by using Junit4 rules. The rule implementation looks like this:

public class ForceLocaleRule implements TestRule {

    private final Locale mTestLocale;
    private Locale mDeviceLocale;

    public ForceLocaleRule(Locale testLocale) {
        mTestLocale = testLocale;
    }

    @Override
    public Statement apply(Statement base, Description description) {
        return new Statement() {
            public void evaluate() throws Throwable {
                try {
                    if (mTestLocale != null) {
                        mDeviceLocale = Locale.getDefault();
                        setLocale(mTestLocale);
                    }

                    base.evaluate();
                } finally {
                    if (mDeviceLocale != null) {
                        setLocale(mDeviceLocale);
                    }
                }
            }
        };
    }


    public void setLocale(Locale locale) {
        Resources resources = InstrumentationRegistry.getTargetContext().getResources();
        Locale.setDefault(locale);
        Configuration config = resources.getConfiguration();
        config.locale = locale;
        resources.updateConfiguration(config, resources.getDisplayMetrics());
    }
}

The test locale is passed in as a parameter to the constructor. Before test execution we set the test locale. When test is executed, the previous device’s locale will be automatically restored.

And here’s an example of a test where locale il setted to Locale.UK before test execution:

@RunWith(AndroidJUnit4.class)
public class MyActivityTest {

    @ClassRule
    public static final ForceLocaleRule localeTestRule = new ForceLocaleRule(Locale.UK);

    @Rule
    public ActivityTestRule<MyActivity> mMyActivityRule = new ActivityTestRule<>(MyActivity.class);

    private Context mContext;

    @Before
    public void setUp() {
    	// ...
    }

    @Test
    public void testSomeMethod() {
    	// ...
    }
}