erdincay

We will gather all URLs next - this may take a short while. Please remain patient.
(1) 3ddesktop                      -> http://desk3d.sourceforge.net/download.php
(2) 3dpong                         -> ftp://ftp.billsgames.com/unix/x/3dpong/src/3dpong-0.5.tar.gz
(3) 855resolution                  -> http://perso.orange.fr/apoirier/
(4) a2png                          -> http://sourceforge.net/projects/a2png/files/a2png/0.1.5/a2png-0.1.5.tar.gz
(5) a2ps                           -> http://ftp.gnu.org/gnu/a2ps/a2ps-4.14.tar.gz
(6) a52dec                         -> http://liba52.sourceforge.net/files/a52dec-0.7.4.tar.gz
(7) aalib                          -> http://sourceforge.net/projects/aa-project/files/aa-lib/1.4rc5/aalib-1.4rc5.tar.gz
(8) aamath                         -> http://fuse.superglue.se/aamath/aamath-0.3.tar.gz
(9) abcde                          -> http://abcde.googlecode.com/files/abcde-2.5.3.tar.gz

chancez

module "combined_acm_certificate" {
  source = "../../modules/acm_certificate_dns_validated_multi_zone"

  domain_name = "infra.example.com"
  zone_to_san = {
    "infra.example.com" = [
      "*.infra.example.com",
      "*.dev.infra.example.com",
      "*.staging.infra.example.com",
      "*.production.infra.example.com",

yegappan

Vim Script for Python Developers

This is a guide to Vim Script development for Python developers. Sample code for the various expressions, statements, functions and programming constructs is shown in both Python and Vim Script. This is not intended to be a tutorial for developing Vim scripts. It is assumed that the reader is familiar with Python programming.

For an introduction to Vim Script development, refer to usr_41.txt, eval.txt and Learn Vimscript the Hard Way

For a guide similar to this one for JavaScript developers, refer to Vim Script for the JavaScripter

This guide only describes the programming constructs that are present in both Python and Vim. The constructs that are unique to Vim (e.g. autocommands, [key-mapping](https://vimhelp.org/map.txt.html#key-m

adwait1-g

1. Downloading and building the Linux kernel

1. Clone the github repository onto your local machine.

$ git clone https://github.com/torvalds/linux.git
$ cd linux

2. Configure the build

ekreutz

Ansible variable precedence

Source: http://docs.ansible.com/ansible/latest/playbooks_variables.html#variable-precedence-where-should-i-put-a-variable

From least to most important

• command line values (for example, -u my_user, these are not variables)
• role defaults (defined in role/defaults/main.yml)
• inventory file or script group vars
• inventory group_vars/all

skyrocknroll

from locust.stats import RequestStats
from locust import Locust, TaskSet, task, events
import os
import sys, getopt, argparse
from random import randint,random
import json
from locust.events import EventHook
import requests
import re
import grpc

thekalinga

Libre office python development environment setup guide

Setup

1. Install Visual studio code
2. Install Python plugin for visual studio
3. Install pyenv that helps you manage multiple versions of python side by side
4. Install pyenv-virtualenv helps you utilize python virtualenvs inside pyenv

git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv

ljharb

Array Iteration

https://gist.github.com/ljharb/58faf1cfcb4e6808f74aae4ef7944cff

While attempting to explain JavaScript's reduce method on arrays, conceptually, I came up with the following - hopefully it's helpful; happy to tweak it if anyone has suggestions.

Intro

JavaScript Arrays have lots of built in methods on their prototype. Some of them mutate - ie, they change the underlying array in-place. Luckily, most of them do not - they instead return an entirely distinct array. Since arrays are conceptually a contiguous list of items, it helps code clarity and maintainability a lot to be able to operate on them in a "functional" way. (I'll also insist on referring to an array as a "list" - although in some languages, List is a native data type, in JS and this post, I'm referring to the concept. Everywhere I use the word "list" you can assume I'm talking about a JS Array) This means, to perform a single operation on the list as a whole ("atomically"), and to return a new list - thus making it mu

subfuzion

Go has excellent build tools that mitigate the need for using make. For example, go install won't update the target unless it's older than the source files.

However, a Makefile can be convenient for wrapping Go commands with specific build targets that simplify usage on the command line. Since most of the targets are "phony", it's up to you to weigh the pros and cons of having a dependency on make versus using a shell script. For the simplicity of being able to specify targets that can be chained and can take advantage of make's chained targets,

lazywithclass

global
    log 127.0.0.1 local0
    user root
    group root
    daemon

defaults
    log     global
    mode    http
    option  httplog