Alejandro Garcia Seco agseco

Dependency Injection in Functional Programming

There exist several DI frameworks / libraries in the Scala ecosystem. But the more functional code you write the more you'll realize there's no need to use any of them.

A few of the most claimed benefits are the following:

Dependency Injection.
Life cycle management.
Dependency graph rewriting.

Summary of book "Clean Architecture" by Robert C. Martin

Uncle Bob, the well known author of Clean Code, is coming back to us with a new book called Clean Architecture which wants to take a larger view on how to create software.

Even if Clean Code is one of the major book around OOP and code design (mainly by presenting the SOLID principles), I was not totally impressed by the book.

Clean Architecture leaves me with the same feeling, even if it's pushing the development world to do better, has some good stories and present robust principles to build software.

The book is build around 34 chapters organised in chapters.

Docker - How to cleanup (unused) resources

Once in a while, you may need to cleanup resources (containers, volumes, images, networks) ...

delete volumes

// see: https://github.com/chadoe/docker-cleanup-volumes

$ docker volume rm $(docker volume ls -qf dangling=true)

$ docker volume ls -qf dangling=true | xargs -r docker volume rm

System Design Cheatsheet

Picking the right architecture = Picking the right battles + Managing trade-offs

Basic Steps

Clarify and agree on the scope of the system

User cases (description of sequences of events that, taken together, lead to a system doing something useful)
- Who is going to use it?
- How are they going to use it?

	package com.yourproject.datastructures;

	import java.io.*;
	import java.util.*;
	import java.util.function.Consumer;

	/**
	* Disk-backed array list
	* @param <E> element type
	*/

	package com.jivimberg.sqs.published

	import kotlinx.coroutines.CancellationException
	import kotlinx.coroutines.CoroutineScope
	import kotlinx.coroutines.isActive
	import kotlinx.coroutines.yield
	import java.lang.Thread.currentThread

	suspend fun CoroutineScope.repeatUntilCancelled(block: suspend () -> Unit) {
	while (isActive) {

	class Middleware {

	constructor() {

	// Array prototype last
	if (!Array.prototype.last) {
	Array.prototype.last = function() {
	return this[this.length - 1];
	}
	}

	package my.netty.http.upload;

	import io.netty.channel.Channel;
	import io.netty.channel.ChannelInitializer;
	import io.netty.channel.ChannelPipeline;
	import io.netty.channel.EventLoopGroup;
	import io.netty.channel.nio.NioEventLoopGroup;
	import io.netty.channel.socket.SocketChannel;
	import io.netty.channel.socket.nio.NioServerSocketChannel;
	import io.netty.handler.codec.http.HttpRequestDecoder;

	image: maven:3.3-jdk-8-alpine

	cache:
	key: "$CI_PROJECT_NAMESPACE/$CI_PROJECT_NAME"
	paths:
	- .m2/

	variables:
	MAVEN_OPTS: "-Dmaven.repo.local=.m2"

	<?php

	namespace App\Providers;

	use Illuminate\Support\ServiceProvider;
	use Log;
	use Config;

	class AppServiceProvider extends ServiceProvider
	{