Docker for Developers

Salutare!

Cu ceva timp in urma, in octombrie 2017, entuziasmat de facilitățile oferite de catre Docker in ceea ce priveste crearea si recrearea unui mediu de lucru foarte rapid pentru a simula cat mai bine anumite conditii ce privesc aspecte ale parti de environment setup pentru development, am avut ocazia sa le prezint colegilor cateva lucruri din cele descoperite.

De unde a plecat totul?

Pentru o aplicație de android ce o dezvoltam aveam nevoie de un mod de lucru in care orice modificare ce eu o aduceam aplicației si era push-uita in “repository-ul central” sa fie rulate anumite teste si mai apoi aplicația sa fie push-uita in store (in varianta alpha).

Căutând zile in sir după extensii de Gradle ce îmi permit sa fac aceasta operațiune am găsit ceva ce intr-adevar ma ajuta in problema respectiva. Toate bune, totul funcționa perfect când cream build-ul local. Cum rămâne cu partea de continuous integration?

Alte zile alte căutări și de încercări am ajuns sa cunosc mai bine Docker-ul încât am creat o imagine ce va invit o folositi si de ce nu extindeti: https://hub.docker.com/r/vladvesa/android-ci/

 

Ce este Docker?

Daca nu sunteti deja in tema puteti citi despre Docker si despre modul in care poate fi folosit chiar aici.

Progresul tehnologiei a permis treptat trecerea de la crearea manuala a environmentului de lucru de fiecare data cand doreai sa incepi dezvoltarea pentru un anumit proiect la crearea unui setup ce permite generarea de imagini ce contin deja toate resursele initiale iar in prezent la folosirea Docker-ului care permite optimizarea consumului de resurse s.a.m.d.

Daca ne referim strict la programarea web am avea XAMPP (WAMP sau MAMP) mai apoi Vagrant iar in cele din urma Docker.

Pentru cei familiari cu programarea orientata pe obiecte puteti vedea abstractizarile din Docker (Imagini si Containere) ca si Clase si Obiecte. Mai pe scurt Imaginile sunt clasele din programare iar instantierea lor da nastere la Obiecte care sunt alternativele containerelor.

 

Ce facilitati ofera?

O imagine ce prezinta avantajele Docker ar fi urmatoarea:

Poti trece ușor de la realizarea unui setup in ore chiar zile in doar câteva secunde. Tot cu ce trebuie sa fie confortabil e:

  • partea de port forwarding
  • comenzi linux pentru instalare/configurare de tool-uri
  • umpic de retelistica
  • umpic de gestionarea volumelor la nivel de docker

Prezentarea?

Un link catre prezentare il gasiti aici: https://docs.google.com/presentation/d/e/2PACX-1vSmaf84DhUP251RUv_Oa8m1wq0tcMvC8X-25wufc9ZkZqrl9czcP2-6BVwjrGPTQe1En-9zlaSF7fMX

 

How To Bypass Skip Ahead is now closed Windows Insider Program

Salut! As vrea sa va povestesc in cateva randuri cum puteti sa treceti mai departe peste problema enuntata in titlu.

Am omis in momentul in care sa lansat developmental pentru Redstone 5 sa trec pe acel branch de development, iar in consecinta zilele astea cand am vrut sa fac modificarea m-am lovit de mesajul de eroare din titlu: “Skip Ahead is now closed Windows Insider Program”. Am cautat asadar modalitati pentru a putea face totusi tranzitia mai ales ca noua versiune de sistem de operare vine cu cateva “imbunatatiri” cum ar fi: tab-uri pentru windows explorer cat si pentru alte programe ce imi sunt utile in viata de zi cu zi.

Am avut norocul sa dau peste acest tutorial (https://www.nextofwindows.com/how-to-bypass-skip-ahead-is-now-closed-windows-insider-program) care desi facut pentru o versiune mai veche de windows merge si in cazul in care vrei sa treci de la RS4 la RS5.

Sper sa va fi fost de folos intrucat eu chiar in acest moment.

 

Lenovo Yoga 720 15IKB

De multa vreme caut un laptop care sa suplinească Apple-ul pe care butonez de vreo 3 ani, caci vine o vreme când chiar și pentru un produs calitativ cum sunt cele de la Apple apare uzura morala (softul vrea mai mult dar hardware-ul începe sa nu mai poată). Pentru a soluționa aceasta problema am achiziționat pe rand un Asus ZenBook Pro 550VD (care l-am returnat) și acum acest Lenovo yoga de care va scriu si de pe care va scriu.

Sincer am fost și sunt entuziasmat sa va scriu întrucât vreau sa va ajut sa luați o decizie buna dacă vreți sa va schimbați laptopul cu ceva mai nou/fancy/performant.

Sa o luam pas cum pas în ceea ce privește ce cautam ce am găsit și ce îmi place si ce nu. Atașat acestui post aveți si o galerie foto pentru a va face o impresie despre ce va vorbesc aici.

Ce am cautat eu la acest înlocuitor:

  • taste retro iluminate
  • un procesor mai bun
  • placa video dedicata (mac-ul nu avea)
  • un sistem de răcire performant (nu vreau ca în timp ce efectuez operațiuni normale cum ar fi browning-ul, scriere cod – atentie nu compilare – … laptopul sa i-a “foc” la mine în brate)
  • o tastatura comoda la tastat (tastez destul de mult)
  • un ecran bun (sincer prefer varianta lucioasa (glossy) … mi se pare mai aspectuos)

Ce oferă laptopul:

  • procesor Kaby Lake 7700HQ – 4 core, 8 threads (2.8 ghz – turbo boost to 3.8)
  • 8 GB , DDR4 (2133 Mhz)
  • o baterie buna de 72W care îmi rezista in utilizare normala vreo 4-5-6 ore
  • ecran cu touchscreen care e absolut impecabil (imi place mult … desi trecand de la un “retina display” pot spune ca nu ma deranjeaza numarul mai redus de pixeli)
  • tastatura: bestiala, mai confortabila decat ceea ce propune orice laptop pe care am pus mana
  • ca si conectivitate:
    • 2 usb 3 normale
    • 1 usb c.
    • nici un port hdmi/vga
    • nici un slot pentru card

Si acum impresiile:

  • ambalaj extraordinar – premium. Cutia e foarte mica întrucât atunci cand l-am ridicat am zis ca sigur nu mi-a fost livrat un laptop mai mic? de 13″ (inch)
  • laptopul este subțire, la fel de subțire ca și mac-ul și cam la fel de greu (are si de ce: e complet aluminiu + are o baterie consistenta)
  • desi vin de la 16 GB ram deocamdată constat ca 8 GB îmi sunt suficienți dar am in plan un upgrade de ram, laptopul având un slot disponibil pentru acest lucru
  • procesorul desi beneficiază de turbo boost acesta este disabled de către producator dar se poate activa pentru cei pătimași (eu nu am ales sa fac acest lucru intrucat laptopul merge repede si bine cum e acum – o sa revin cu un tutorial cum puteți activa aceasta funcționalitate)
  • bateria asa cum zicea tine vreo 4-5-6 ore , depinde de ce faci (eu vorbesc aici de light spre medium usage)
  • tastatura – arata bine, e spatioasa, retroiliuminata si cu un key travel foarte bun incat sa simti ca tastezi
  • la conectivitate într-adevăr as zice ca laptopul e cam “subțire” nu prea ai multe porturi si chiar am fost ingrijorat de acest lucru cand l-am achizitionat.  Când am deschis pachetul ce sa vezi: surpriza: adaptorul usb c – hdmi si usb c – vga sunt incluse la pachet (nice gift lenovo). Mai ramane acum problema card reader-ului pentru cei ce fac fotografie si au nevoie de asa ceva in mod constant
  • când vine vorba de ecranul tactil: e meserie. Daca vrei sa cumperi acest laptop pentru photo editing (desi nu ai card reader) tin sa precizez ca vin la cutie cu graphic pen – un lucru destul de important de știut întrucât “o scula” de asta costa cam 100$ (again nice gift lenovo)
  • o chestie problematica in perspectiva ar putea fi balamalele ecranului care momentan sunt destul de rigide si sper sa nu imi ofere probleme in viitorul îndepărtat (vorbesc aici de 2-3 ani)

Singleton done right in C++ 11

Today searching the internet I’ve found a “cool” and simple method to create a safe singleton that performs well in multithreading environment.

With a small amount of lines you can achieve both: safe initialization and multithreading safety.

class Singleton {
     static std::once_flag onceFlag;
     static Singleton* instance;
public:
     static Singleton& getInstance(){
          std::call_once(onceFlag, []{
               instance = new Singleton();
          });
          return *instance;
     }

private:
     Singleton(){};
}

 

As c++ documentation says the:

  • The class std::once_flag is a helper structure for std::call_once.
    An object of type std::once_flag that is passed to multiple calls to std::call_once allows those calls to coordinate with each other such that only one of the calls will actually run to completion.
    std::once_flag is neither copyable nor movable.
  • The std::call_once executes the Callable object f exactly once, even if called from several threads.

 

Having this in mind stay save and use singleton in a safe way!

Happy coding!

Turbo boost disabler for Mac OSX

Searching a better way to improve battery life when compiling programs without a connected charger I’ve found Turbo Boost Switcher. This software instructs the CPU to work at it’s limited hardware clock and not taking advance of the extra juice offered by the turbo boost technology.

While on Linux or Windows this can be achieved very easily using the performance tuner for each Power Profile, on mac this is almost impossible with the onboard tools supplied by apple.

Attention while using this tool since it’s not an apple supplied software it may lead to unexpected system behaviour. This is highly unlikely to happen, but be careful.

The PIMPL idiom

The purpose

Remove compilation dependencies on internal class implementations and improve compile times.

The story behind

When a header file changes, any files that #include that file will need to be recompiled. In the case of a class header, this is true even if those changes only apply to private members of the class. The PIMPL idiom hides private members from any users of the header file, allowing these internal details to change without requiring recompilation of the client code.

Lines 5–17 define a class, foo, to which we have applied the PIMPL idiom. This class definition includes only the public interface of the class and a pointer to the internal implementation. We use a std::unique_ptr (line 16) to ensure the lifetime of the implementation is managed correctly, which we initialise in foos constructor (line 35).

While the internal implementation class, impl, is declared in the header file on line 15, its definition appears in the implementation file on lines 22–32. This allows the class definition to change without requiring users of foo to recompile.

We have explicitly defaulted foo’s destructor on line 40, which is necessary because the destructor needs to be able to see the complete definition of impl (in order to destroy the std::unique_ptr). Note that we have also explicitly defaulted the move constructor and assignment operator on lines 42–43 so that foo can be moved. To make foo copyable, we must also implement the copy constructor and assignment operator.

Note: std::make_unique was introduced in C++14. For C++11, you can roll your own implementation.

 

Brief example

// foo.h - header file
#include <memory>
class foo
{
    public:
        foo();
        ~foo();
        foo(foo&&);
        foo& operator=(foo&&);
    private:
        class impl;
        std::unique_ptr pimpl;
};
// foo.cpp - implementation file
class foo::impl
{
    public:
        void do_internal_work()
        {
            internal_data = 5;
        }
    private:
        int internal_data = 0;
};
foo::foo()
    : pimpl{std::make_unique()}
{
    pimpl->do_internal_work();
}
foo::~foo() = default;
foo::foo(foo&&) = default;
foo& foo::operator=(foo&&) = default;

 

Inheritance in C++

The question:

I looked and couldn’t find a good explanation of the difference between public, private, and protected inheritance in C++. All of the questions I’ve found deal with specific cases. What is the difference in general?

The answer:

There are three accessors that I’m aware of: public, protected and private.

Lets take the following example:

class Base {
    public:
        int publicMember;
    protected:
        int protectedMember;
    private:
        int privateMember;
};

Everything that is aware of Base is also aware that Base contains publicMember. Only the children (and their children) are aware that Base contains protectedMember. No one but Base is aware of privateMember. By is aware of, I mean acknowledge the existence of, and thus be able to access.

The same happens with public, private and protected inheritance. Let’s consider a class Base and a class Child that inherits from Base.

  • If the inheritance is public, everything that is aware of Base and Child is also aware that Child inherits from Base.
  • If the inheritance is protected, only Child, and its children, are aware that they inherit from Base.
  • If the inheritance is private, no one other than Child is aware of the inheritance.