patrickelectric

#Download ardusub image
wget https://s3.amazonaws.com/downloads.bluerobotics.com/Pi/stable/ardusub-raspbian.img.zip
unzip ardusub-raspbian.img.zip
#mount image as device
sudo kpartx -va 0.0.10.img
sudo mkdir -p /mnt/image
#mount device partition as folder
sudo mount /dev/mapper/loop0p2 image
#move qemu inside /usr/bin
sudo cp /usr/bin/qemu-arm-static image/usr/bin

larsch

#!/bin/sh -exu
dev=$1
cd $(mktemp -d)

function umountboot {
    umount boot || true
    umount root || true
}

# RPi1/Zero (armv6h):

cryzed

Disclaimer: Please follow this guide being aware of the fact that I'm not an expert regarding the things outlined below, however I made my best attempt. A few people in IRC confirmed it worked for them and the results looked acceptable.

Attention: After following all the steps run gdk-pixbuf-query-loaders --update-cache as root, this prevents various gdk-related bugs that have been reported in the last few hours. Symptoms are varied, and for Cinnamon the DE fails to start entirely while for XFCE the icon theme seemingly can't be changed anymore etc.

Check the gist's comments for any further tips and instructions, especially if you are running into problems!

Screenshots

Results after following the guide as of 11.01.2017 13:08:

tasdikrahman

A Typical directory structure for running tests using unittest

Ref : stackoverflow

The best solution in my opinion is to use the unittest [command line interface][1] which will add the directory to the sys.path so you don't have to (done in the TestLoader class).

For example for a directory structure like this:

new_project

├── antigravity.py

karenyyng

Table Of Content

Skip to the relevant sections if needed.

• 2-min tutorial to do it the quick-and-dirty-way
• Concepts for resolving Git conflicts
• Setting up different editors / tool for using git mergetool
  • Finding out what mergetool editors are supported
• mergetool simple code example for vimdiff
  • Resolving conflict from a Git pull
• Other great references and tutorials

outro56

progrium/bashstyle

Bash is the JavaScript of systems programming. Although in some cases it's better to use a systems language like C or Go, Bash is an ideal systems language for smaller POSIX-oriented or command line tasks. Here's three quick reasons why:

• It's everywhere. Like JavaScript for the web, Bash is already there ready for systems programming.
• It's neutral. Unlike Ruby, Python, JavaScript, or PHP, Bash offends equally across all communities. ;)
• It's made to be glue. Write complex parts in C or Go (or whatever!), and glue them together with Bash.

This document is how I write Bash and how I'd like collaborators to write Bash with me in my open source projects. It's based on a lot of experience and time collecting best practices. Most of them come from these two articles, but here integrated, slightly modified, and focusing on the most bang for buck items. Plus some ne

egel

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sublime_plugin
import subprocess
from time import sleep
import sys
 
cl = lambda line: subprocess.Popen(line, shell=True, stdout=subprocess.PIPE).communicate()[0].strip()
log = lambda message: sys.stderr.write("Log: %s\n" % message)

radarsat1

#!/usr/bin/env python

"""Provide a parallelized version of scipy.optimize.brute for 1-, 2-, or 3-dimensional arguments.

Needed to parallelize the steps of a grid-based global optimization, so I copied the "brute" code, replaced "vectorize" with nested maps for specific numbers of arguments, and replaced the outer-most map() with a ThreadPool.map().  Likely this could be generalized to any number of arguments (e.g. by zipping the grid and iterating in parallel over the tuples) but I didn't feel like figuring that out just now.

This should perform help for routines that spend a lot of time in numpy code, but I imagine that a pure Python routine might get caught-up by the GIL.  Possibly using a process pool instead of a thread pool would fix it.  Currently I'm using it for a routine that spends all its time in fftconvolve() so it wasn't a problem for me.

parbrute() takes the same arguments as scipy.optimize.brute(), with the addition of thread=N for the number of threads you want in the pool.  Defaults to 4