Local Riders

localriders

Open source today is a word that often include a lot of things, such as open knowledge (Wikimedia projects), open hardware (Arduino, Raspberry Pi), open formats (ODT/ODS/ODP) and so on. It is a world of opportunities that can be difficult for newcomers but also for intermediates. This article will help you discover how to approach specific roles, activities or projects/communities in the best way. Everything Started with "Coaching for OpenSource Communities 2.0" I decided to write a book in my personal style about my experience in the last 7 to 8 years in open source. I was surprised when I reached 100 pages about various different topics. My idea was to write something that I would like to read, so nothing that is boring or complicated, but full of real facts. The second goal was to include my experience but also my philosophy on contributing and how I contribute daily. Thirdly, I wanted to give a lot of hints and resources and an overall view of this open source world. Basically, I wanted to write something different from self-help or coaching books that includes just a list of suggestions and best practices. Instead, I  take real examples from real life about the OSS world. As a contributor and developer, I prefer to have real cases to study, because best practices are useful, but we need to learn from others and this world is full of good and bad cases to discover. In 2019, I started writing a book after and after 2 years inside the . In that Fosdem edition, I had a talk " " and after the feedback at the conference and my thoughts in various roles, activities, and projects, it was time to write something. Fosdem 2019 Mozilla Reps Council Coaching for Open Source Communities 2.0 At the end it wasn't a manual but a book that included my experience, learnings, best practices and so on in Localization, Development, Project Maintainer, Sysadmin, Community Management, Mentor, Speaker and so on. It contains the following sections: Biography - This choice isn't for self promotion but just to understand my point of view and my story that can be inspiring for others Philosophy - Not the usual description of Open Source or the 4 freedoms, but just what Open Source means and how you can help How to live inside the Open Source - A discovery about communications and tools, understanding the various kind of people and the best way to talk with your community How to choose a project - Starting with some questions to yourself and how to involve more people in your project The activity - Open Source is based on tasks that can be divided in 2 levels: Support, Testing, Marketing, Development etc How to use your time - We are busy, we have a life, a job and a family but Open Source can be time-consuming Why document is important - How writing documentation can be healthy for your community and the project's future and brand There are also three appendices that are manuals which I wrote throughout the years and gathered and improved for this book. They are about: community management, public speaking, and mentoring. The book ends with my point of view about the future and what we have to do to change opinions about those topics. I wrote this book and published in October 2019, but it was only possible with the help of reviews and localizers that improved and contributed. Yes, because this book is open source and free for everyone. I picked the GPL license because this license changed the world and my life in the best way. Using this license is just a tribute. This decision usually is not clear because after all this is a book and there are better licenses like Creative Commons. Second edition After coming back from Fosdem 2020, I started writing notes and gathering feedback from readers. With the lockdown in Italy for Covid-19 in February/March/April I started writing the second edition. Now topics like burn out, project management, delegating, more sections in the appendixes and a lot was added to this new edition. I published the new release a few days before my 30 birthday with 115 pages of "opensourcefulness" that is waiting you! In a week after the publishing, this new edition got the same downloads in GitHub as the previous edition in just 9 months. Looking at the first feedback, readers appreciate the new edition. Download the Book for Free The book is available for free on and where you can download it in PDF/Mobi/Epub. Leanpub GitHub Leanpub requires an account, but you can give a donation or subscribe to get notifications when there is a new edition. It is also on GitHub and it is possible to open tickets or see the markdown version of the book itself. I want to say thank you to all the people that helped me with the review for my English and also those who gave opinions and feedback. I am still open to feedback for the next edition! Previously published at https://daniele.tech/2020/07/contribute-to-open-source-the-right-way-2nd-edition-download-the-free-open-book-now

An Open-Source Book About the Open Source World

What is WebRTC? WebRTC stands for Web Real Time Communication. From webrtc.org: "With WebRTC, you can add real-time communication capabilities to your application that works on top of an open standard. It supports video, voice, and generic data to be sent between peers, allowing developers to build powerful voice and video communication solutions" The API is actually not so big and complicated as it sounds. The MDN website is, as always, very complete . https://developer.mozilla.org/en-US/docs/Glossary/WebRTC We have 3 main parts: getUserMedia(): sends a signal to the browser to ask the user for permission and returns the "stream" of audio/video/data RTCPeerConnection: two participants are called peers, local and remote. Not necessarily physically remote, can be two browsers in the same computer. RTCDataChannel: two peers connect via a channel in a bidirectional way to transfer data. A peer can have up to 65,534 data channels (depends on the browser) In webrtc.org we can find many useful samples https://webrtc.github.io/samples/ Let's dissect a basic peer-to-peer connection. demo: https://webrtc.github.io/samples/src/content/peerconnection/pc1/ code: https://github.com/webrtc/samples/tree/gh-pages/src/content/peerconnection/pc1 First, we will need two video elements, one to see the other person and another one to see ourselves: < = > video id "localVideo" playsinline autoplay muted </ > video < = > video id "remoteVideo" playsinline autoplay </ > video Then the controls to start, call and hangup: Start Call Hang Up < = > button id "startButton" </ > button < = > button id "callButton" </ > button < = > button id "hangupButton" </ > button Now we can start using the WebRTC API to handle all the peer-to-peer connection events. First we set some global variables, get GUI elements and add click handlers: startButton = .getElementById( ); callButton = .getElementById( ); hangupButton = .getElementById( );

startButton.addEventListener( , start);
callButton.addEventListener( , call);
hangupButton.addEventListener( , hangup); localVideo = .getElementById( ); remoteVideo = .getElementById( ); localStream; pc1; pc2; offerOptions = { : , : ,
}; const document "startButton" const document "callButton" const document "hangupButton" "click" "click" "click" const document "localVideo" const document "remoteVideo" let let let const offerToReceiveAudio 1 offerToReceiveVideo 1 When we click start, basically we want to ask the user for permission to use the camera and microphone with getUserMedia(): { { stream = navigator.mediaDevices.getUserMedia({ : , : ,
    });

    localVideo.srcObject = stream;
    localStream = stream;
  } (e) {
    alert( );
  }
} async ( ) function start try const await audio true video true catch `getUserMedia() error: ` ${e.name} When starting a call, we are going to establish a connection between two peers, adding each other ICECandidates, set local audio/video tracks, create a connection offer from peer 1 and create an answer from peer 2: { configuration = {};

  pc1 = RTCPeerConnection(configuration);
  pc1.addEventListener( , (e) => onIceCandidate(pc1, e));

  pc2 = RTCPeerConnection(configuration);
  pc2.addEventListener( , (e) => onIceCandidate(pc2, e));
  pc2.addEventListener( , gotRemoteStream);

  localStream.getTracks().forEach( pc1.addTrack(track, localStream)); { pc1.createOffer(offerOptions); onCreateOfferSuccess()
  } (e) {
    onCreateSessionDescriptionError(e);
  }
} { { pc2.createAnswer();
  } (e) {
    onCreateSessionDescriptionError(e);
  }
} { .log( );
} async ( ) function call const new "icecandidate" new "icecandidate" "track" ( ) => track try await await catch async ( ) function onCreateOfferSuccess try await catch ( ) function onCreateSessionDescriptionError error console `Failed to create session description: ` ${error.toString()} From the code above, we notice that we need an RTCIceCandidate, it represents a Internet Connectivity Establishment. It describes all under-the-hood logic needed for two peers to communicate, protocols, routing, error correction, etc. Here we will add the candidates on both sides: { pc === pc1 ? : ;
} { pc === pc1 ? pc2 : pc1;
} { { getOtherPc(pc).addIceCandidate(event.candidate);
  } (e) {
    onAddIceCandidateError(pc, e);
  }
} { .log( );
} ( ) function getName pc return "pc1" "pc2" ( ) function getOtherPc pc return async ( ) function onIceCandidate pc, event try await catch ( ) function onAddIceCandidateError pc, error console ` failed to add ICE Candidate: ` ${getName(pc)} ${error.toString()} After adding ICE candidates, we added a listener to the "track" event. We will add the event stream to the srcObject of the video element: { (remoteVideo.srcObject !== e.streams[ ]) {
    remoteVideo.srcObject = e.streams[ ];
  }
} ( ) function gotRemoteStream e if 0 0 This should give us video from both sides. Finally, to hangup a call, we close the peer connections and set them to null: {
  pc1.close();
  pc2.close();
  pc1 = ;
  pc2 = ;
} ( ) function hangup null null I hope I simplified enough the webrtc.org basic peer connection example https://github.com/webrtc/samples/tree/gh-pages/src/content/peerconnection/pc1 so you can start creating awesome video call applications. Of course for a production ready service, we will have to consider a lot more. Happy coding.

Understanding WebRTC 

It was said a lot about why ORM is an anti-pattern. The core reason is described . The main point is that the way data is stored and retrieved is an intrinsic property of any object. But ORM seems to be the “first-class citizen”: we explicitly call its methods when we need to fetch some data, and ORM frames it as an object; we call ORM’s functionality when we need to persist an object. In both cases ORM operates upon our objects, treating them as data bags. It’s really pretty offensive. So I’d rather invert this: I want my objects to call ORM, not the other way round. here So, what is an object? After all, what is an object? It’s a representative of some thing from real life, from our ubiquitous language. The way its data is stored is just an implementation detail. I want it to be encapsulated within my object borders. Who said that all object’s data must be stored as object properties? Who said that object contains any data? Is it calculated on the fly? Is it stored in memory? Is it stored on disk? Is it stored in the cloud? It doesn’t matter. Object is not a data bag. Just like , it exposes behavior instead, not data. This principle is called , and it is a manifestation of encapsulation — fundamental OOP concept. my microservices Uniform Access Principle Persistent object state So my persisted object encapsulates two things: the first one is used by the object in order to get to the store, and the second one is used by the object in order to find or save its data. The example taken : here PgHuman Human{ transient PgSource src; final class implements /*** Data source.*/ private final _/\*\*  
 \* Number of it.  
 \*/_    **private final** transient long number;  

PgHuman(**final** PgSource source, **final** long num)  
{  
    this.src = source;  
    this.number = num;  
} } But one thing concerns me in implementation of this concept. Again, consider class. There is definitely both database query logic and business logic inside it. Look at the next() method. It retrieves a talk with unread message, and if there is no such, starts a new talk relating to random question without any messages and which wasn’t asked by current user. I think it would be great to separate these responsibilities. I fully understand that database switching happens quite rarely, but nevertheless it would be helpful for local integration tests, where data would be stored just in memory. PgHuman Better implementation So what about quite evident step to factor the database logic out and hide it behind an interface? Consider an example based on .Here is an implementation: this article PurchaseOrder IPurchaseOrder{ ; class implements /*** @var OrderStorage*/ private $storage _/\*\*  
 \*_ **_@var_** _OrderId  
 \*/_    **private $id**;  

**public function** \_\_construct(OrderStorage $storage, OrderId $id)  
{  
    $this->**storage** \= $storage;  
    $this->**id** \= $id;  
}  

**public function** newInvoice(  
    IInvoiceNumber $invoiceNumber,  
    IVendorInvoiceNumber $vendorInvoiceNumber,  
    DateTime $dateTime,  
    InvoiceAmount $amount  
)  
{  
    $this->**storage**\->save($invoiceNumber, $vendorInvoiceNumber, $dateTime, $amount);  

    **return new** Invoice($this->**storage**, $invoiceNumber);  
} } So all database logic is put inside storage’s ‘save()’ method. It could be transaction handling, some inserts in related tables, explicit locks, etc. The nice thing is that domain class PurchaseOrder is not coupled at all to database-specific code.In case we use any relational database with an imaginary database abstraction library, our storage code might look like the following: SQLOrderStorage OrderStorage{ ; class implements private $connection **public function** \_\_construct(SQLConnection $connection)  
{  
    $this->**connection** \= $connection;  
}  

**public function** save(  
    IInvoiceNumber $invoiceNumber,  
    IVendorInvoiceNumber $vendorInvoiceNumber,  
    DateTime $dateTime,  
    InvoiceAmount $amount  
)  
{  
    **new** InsertQuery($this->**connection**)  
        ->into(**'invoice'**)  
        ->set(**'invoice\_number'**, $invoiceNumber->value())  
        ->set(**'vendor\_invoice\_number'**, $vendorInvoiceNumber)  
        ->set(**'datetime'**, $dateTime)  
        ->set(**'amount'**, $amount->amount())  
        ->set(**'currency'**, $amount->currency())  
    ;  
} } Need Memcached caching? No problem, let’s use a decorator: MemcachedOrderStorage OrderStorage{ ; ; class implements private $storage private $memcachedClient **public function** \_\_construct(OrderStorage $storage, MemcachedClient $memcachedClient)  
{  
    $this->**storage** \= $storage;  
    $this->**memcachedClient** \= $memcachedClient;  
}  

**public function** save(  
    IInvoiceNumber $invoiceNumber,  
    IVendorInvoiceNumber $vendorInvoiceNumber,  
    DateTime $dateTime,  
    InvoiceAmount $amount  
)  
{  
    $this->**storage**\->save($invoiceNumber, $vendorInvoiceNumber, $dateTime, $amount);  

    $this->**memcachedClient**\->set(  
        $invoiceNumber->value(),  
        _base64\_encode_(  
            json\_encode(  
                \[  
                    **'invoice\_number'** \=> $invoiceNumber->value(),  
                    **'vendor\_invoice\_number'** \=> $vendorInvoiceNumber->value(),  
                    **'datetime'** \=> $dateTime->format(**'c'**),  
                    **'amount'** \=> $amount->amount(),  
                    **'currency'** \=> $amount->currency(),  
                \]  
            )  
        )  
    );  
    ;  
} } Need in-memory caching? Let’s use a decorator again: LocalOrderStorage OrderStorage{ ; ; class implements private $storage private $localStorage **public function** \_\_construct(OrderStorage $storage)  
{  
    $this->**storage** \= $storage;  
    $this->**localStorage** \= \[\];  
}  

**public function** save(  
    IInvoiceNumber $invoiceNumber,  
    IVendorInvoiceNumber $vendorInvoiceNumber,  
    DateTime $dateTime,  
    InvoiceAmount $amount  
)  
{  
    $this->**storage**\->save($invoiceNumber, $vendorInvoiceNumber, $dateTime, $amount);  

    $this->**localStorage**\[$invoiceNumber->value()\] =  
        \[  
            **'invoice\_number'** \=> $invoiceNumber->value(),  
            **'vendor\_invoice\_number'** \=> $vendorInvoiceNumber->value(),  
            **'datetime'** \=> $dateTime->format(**'c'**),  
            **'amount'** \=> $amount->amount(),  
            **'currency'** \=> $amount->currency(),  
        \]  
    ;  
} } Transaction management You shouldn’t worry about transaction management as well. If you are into , you are aware of concept. In short, it is a quantum of consistency boundaries in your domain model. Something that absolutely must hold its invariants at all times. And you probably aware of rule of thumb when mutating aggregates: one aggregate per transaction, and the next aggregate is usually triggered by an event, published by the current one. of such approach. So there are no transactions spanning several aggregate roots. In my example, ‘PurchaseOrder’ class is an aggregate root, and all transaction logic can reside inside ‘SQLOrderStorage’. DDD aggregate root Here is an example Polyglot objects This concept spans not only SQL-speaking objects, NoSQL-speaking objects or any other storage-specific-language-speaking objects, but any objects whose data is kept not only in memory. This includes some remote json/xml/etc resource, or a local file. For example, if I can find my financial transaction by calling some API, transaction class could look like this: FinancialTransaction{ ; ; class private $dataSource private $id **public function** \_\_construct(TransactionDataSource $dataSource, TransactionId $id)  
{  
    $this->**dataSource** \= $dataSource;  
    $this->**id** \= $id;  
}  

**public function** isSuccessful()  
{  
    **return** $this->**dataSource**\->isSuccessful();  
} } And data source implementation can be like the following: TransactionDataSource{ isSuccessful(TransactionId $transactionId);} interface public function HttpTransactionDataSource TransactionDataSource{ ; class implements private $connection **public function** \_\_construct(Connection $connection)  
{  
    $this->**connection** \= $connection;  
}  

**public function** isSuccessful(TransactionId $transactionId)  
{  
    (**new** Response(  
        **new** PostHttpRequest(  
            $this->**connection**\->uri(),  
            **new** HttpVersion(**'HTTP/1.1'**),  
            \[  
                $this->**connection**\->credentials(),  
                **new** Header(**'Content-Type: application/xml'**),  
                **new** Header(**'SOAPAction: ""'**),  
            \],  
            **new** RequestBody(  
                (**new** SimpleXMLElement(**"<data></data>"**))  
                    ->addChild(**'transaction\_id'**, $transactionId->value())  
            ),  
            $this->**connection**\->transport()  
        )  
    ))  
        ->value()  
    ;  
} } Wrapping it up Well, this approach is nothing more than inverted ORM/HTTP call/etc. But the conceptual difference is huge.The main point, the motivational force in this approach is in the notion of an “object”. It is a declarative concept, representing real-life entities. Object who knows what to do and how. Object who doesn’t need any instructions. Object who doesn’t need to be orchestrated or controlled in any way. Finally, an object, who possesses all resources or it needs to do its job. services Using human metaphor, objects are adults, not kids.

You Don’t Need an ORM

DI containers, when used wrong, i.e., in most cases, are not just , but the absolute evil. code polluters It’s a static dependency DI containers are very often called from all over the place. DI container in this case is just a , which is a singleton. Singleton with huge amount of methods. Besides that it introduces . That’s how it might look like: service locator hidden dependencies PaymentProcessor{ purchase(){ DIPaymentModuleFactory:: ()->purchase();}} class public function return me To remedy this mistake, the only way is to use it only on the highest level of an application, preferably in index file where an application starts. And if you’d use it that way — do you really still need it? You don’t anyway. It’s already, and there are two more points ahead. Catch-22 It breaks one of the most solid OOP metaphors DI container breaks the metaphor of a that David West talks about in his book . I want my classes to be instantiated in a single place, and this place should be an entry point of any request or message. Their collaboration should be achieved only with composition. And composability is the goal that any aspiring object-thinker is striving for. Lego brick Object Thinking It breaks cohesion Moreover, it breaks fundamental OOP principles — data encapsulation and exposing behavior instead. Why the way an object should be instantiated is hidden to the program code? Why is it put in some ? Really, think about it — it’s nonsense! This point is even broader. Why do we ever need a config file? Why is some piece of data torn apart of its behavior? This is exactly what talked about 14 years ago, right? And everyone seems to agree with that. But why do we keep following this concept? Configuration files are just reflective of a procedural mindset! configuration file Martin Fowler Life without DI-container It’s a . So that’s how my entry point usually looks like: pure Dependency Injection { ( PurchaseOrder( LocalOrderStorage( NullOrderStorage()), OrderId($inputParams[ ])))->newInvoice( InvoiceNumber( Vendor( LocalVendorStorage(), VendorId($inputParams[ ])), VendorInvoiceNumber($inputParams[ ]), DateTime($inputParams[ ])), VendorInvoiceNumber($inputParams[ ]), DateTime($inputParams[ ]), InvoiceAmount( Amount($inputParams[ ]), Currency($inputParams[ ])))->json();} (Exxeption $exxeption) { ( ErrorResult())->json($exxeption->getCode(), $exxeption->getMessage());} try echo new new new new 'order_id' new new new new 'vendor_id' new 'vendor_invoice_number' new 'date_time' new 'vendor_invoice_number' new 'date_time' new new 'amount' new 'currency' catch return new It’s wonderful. Join me.

Stories, News & Mentions about LOCALRIDERS

Localriders’s Stories on HackerNoon