Jesús García Crespo sevein

Behaviors of Python threading, multiprocessing and concurrent.futures

I saw the behaviors as follows:

threading.Thread and multiprocessing.Process do not raise to the main thread.
multiprocessing.Pool and multiprocessing.pool.ThreadPool (this is not documented at all) leave zombie threads.

The results show that concurrent.futures is the best choice for threading and multiprocessing in Python!

I did this experiment on Python 2.7.9, and Python 2.x does not have concurrent.futures, so I installed it by pip command pip install futures.

Striking Out with Islandora 2.x, Fedora 4.x, and Apache Camel

Kevin Bowrin, 2015-02-27

A few days ago, Nick Ruest and the Islandora Foundation made available the technical documentation for the upcoming version of Islandora. The Islandora Foundation should be commended for their transparency and community building efforts. Even in this early stage of Islandora 2.x, the documentation has a great introduction to Islandora, the goals of the project, the planned architecture, and installation instructions for their Vagrant development box.

The Technical Design for the next version of Islandora reminds me of something Mike Giarlo said, when I was waxing on about my dream Digital Library / R

Rust developer tools - status and strategy

Availability and quality of developer tools are an important factor in the success of a programming language. C/C++ has remained dominant in the systems space in part because of the huge number of tools tailored to these lanaguages. Succesful modern languages have had excellent tool support (Java in particular, Scala, Javascript, etc.). Finally, LLVM has been successful in part because it is much easier to extend than GCC. So far, Rust has done pretty well with developer tools, we have a compiler which produces good quality code in reasonable time, good support for debug symbols which lets us leverage C++/lanaguge agnostic tools such as debuggers, profilers, etc., there are also syntax highlighting, cross-reference, code completion, and documentation tools.

In this document I want to layout what Rust tools exist and where to find them, highlight opportunities for tool developement in the short and long term, and start a discussion about where to focus our time an

Channels Are Not Enough

... or Why Pipelining Is Not That Easy

Golang Concurrency Patterns for brave and smart.

By @kachayev

Intro

Terraform, CoreOS, and Digital Ocean

Let's use Terraform to easily get a CoreOS cluster up on Digital Ocean. In this example we will get a 5 node CoreOS cluster up and running on the Digital Ocean 8GB size.

Install Terraform

Grab a copy of Terraform for your platform from http://www.terraform.io/downloads.html. Follow the instructions at http://www.terraform.io/intro/getting-started/install.html by getting Terraform in your PATH and testing that it works.

Digital Ocean API Key

A state machine is defined as follows:

Input - a set of inputs
Output - a set of outputs
State - a set of states
S0 ∈ S - an initial state
T : Input * State -> Output * State - a transition function

If you model your services (aggregates, projections, process managers, sagas, whatever) as state machines, one issue to address is management of State. There must be a mechanism to provide State to the state machine, and to persist resulting State for subsequent retrieval. One way to address this is by storing State is a key-value store. Another way is to use a SQL database. Yet another way is event sourcing. The benefit of even sourcing is that you never need to store State itself. Instead, you rely on the Output of a service to reconstitute state. In order to do that, the state machine transition function needs to be factored into two functions as follows:

	// Source: http://nicolasmerouze.com/guide-routers-golang/

	// Package httprouterwrapper allows the use of http.HandlerFunc compatible funcs with julienschmidt/httprouter
	package httprouterwrapper

	import (
	"net/http"

	"github.com/gorilla/context"
	"github.com/julienschmidt/httprouter"

	# Hello, and welcome to makefile basics.
	#
	# You will learn why `make` is so great, and why, despite its "weird" syntax,
	# it is actually a highly expressive, efficient, and powerful way to build
	# programs.
	#
	# Once you're done here, go to
	# http://www.gnu.org/software/make/manual/make.html
	# to learn SOOOO much more.

	package main

	import (
	"net/http"
	"database/sql"
	"fmt"
	"log"
	"os"
	)

	{
	"atom": ["https://www.accesstomemory.org/docs/latest/", null],
	"archivematica": ["https://www.archivematica.org/docs/archivematica-latest/", null],
	"storageservice": ["https://www.archivematica.org/docs/storage-service-latest/", null]
	}