I have been having a lot of success using Make to build my Docker-based microservices ecosystem of about a dozen services and about half a dozen backend servers. I also use Make to remember how to build and tag my containers to push to AWS ECR for deployment, which I would never remember how to do if I had to type it out every day.

I use Makefiles for every Python project, personal and professional. Maybe there’s a better way, but it works for me and my teammates quite well. Here’s a redacted example from a recent one:

PROJECT_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
PROJECT_BASE := "somebasename"
PROJECT_NAME := "someprojectname"
VERSION := $(shell grep "version=" setup.py | sed --expression="s/.*version='\([0-9]\+\.[0-9]\+\.[0-9]\)',/\1/g")

.PHONY: env
env:
	@virtualenv env --no-site-packages


ifneq "$(VIRTUAL_ENV)" ""

.PHONY: setup
setup:
	@python $(PROJECT_DIR)/setup.py develop
	@pip install --upgrade --editable .[tools]

.PHONY: clean
clean:
	@find $(PROJECT_DIR)/src/ -type f -name '*.pyc' -delete

.PHONY: test
test: clean
	@nosetests --nocapture test/

.PHONY: lint
lint: clean
	@pylint setup.py $(PROJECT_DIR)/src/$(PROJECT_BASE)/

endif  # VIRTUALENV


.PHONY: version
version:
ifdef tag
	@echo "Setting version to $(tag)"
	@sed --in-place --expression="s/$(VERSION)/$(tag)/" $(PROJECT_DIR)/README.md
	@sed --in-place --expression="s/version='$(VERSION)'/version='$(tag)'/" $(PROJECT_DIR)/setup.py
endif
	@head -n1 README.md

So now all common tasks are at your fingertips, make env, make setup, make lint, make test and bumping the version with make version. Usually have a bunch of other stuff in there too once the project gets going, maybe make server and stuff like that.

I enjoy the style that this book is written, and have already been on an Elixir self-study regimen. Question for author or anyone who’s gone through this already: the beginning seems to be very beginner oriented, is there added value later for experienced programmers coming from other languages?

The Lies of Locke Lamora, the first book of The Gentleman Bastards series.

It starts off slow and seems more like Oliver Twist than a fantasy novel, but its charm pulled me in. Over time the fantasy elements and broader scope start to work their way in and by then I was completely invested in the characters and their plights. It’s a unique take, about 2/3 through but I can already highly recommend.

The code examples are really wonderful to back up the points he’s making. I’ve only dabbled with Erlang/Elixir but am bookmarking this to see how I can apply these techniques to current problems I’m trying to solve with small one-off scripts.

I’m a simple man, I use Simplenote for pretty much everything since it’s available on all my devices and… simple. I have a note titled {company_name}: STATUS that’s just a long list of dated sections with any notes I take that day, including notes from standup and such. If anything ends up being too long or worth keeping a handy reference to I’ll break it out into another note like {company_name}: {some_app}: troubleshooting or such and reference the title in the STATUS note. You can see a lot of the value comes from naming convention for the note titles.

I really do use Simplenote for everything from work, to grocery lists, to music I want to check out, to Minecraft base locations, etc.

I never understood the power of currying either until I started using Clojure heavily for stream processing. Now I use them so much by default I think about how to construct partials for their versatility in use. For example, I can have a single function that creates stream processors based on various rules loaded from configs at startup. That way, the creation of the stream processor only occurs once at startup when the first argument is passed in, improving performance when the returned stream function is called since any config processing has already occurred. A generalized sanitized example:

(defn process-rules
  [rule-fn & downstreams]
  (fn [event] (apply (rule-fn event) downstreams)))

(defn apply-rule
  [rule event]
  (...do some stuff with rule to process event...))

(defn create-stream-processor
  [some-rules]
  (partial process-rules
              (fn [event] (map (fn [rule] (apply-rule rule event)) some-rules))))

I may have sanitized too much for that to make sense or parse correctly. But the point is also, if you’re not used to currying regularly, this might not even make sense regardless, let alone be the first way you’d think of approaching the problem of stream processing.

Interesting idea. Curious that this only resulted in 4 lines of output even when I let it run for a while though:

while true; do date +'%s'; sleep 1; done | nc seashells.io 1337

[Comment removed by author]

I’m new here, so is this only about downvoting comments or also threads? I can only downvote comments, but I suspect this is because of my low karma.

P.S.: I also wanted to write “Can’t upvote this thread enough” but realized it would have been a “me too” ;-)

The only thing that keeps me sane is using weechat to connect: https://github.com/wee-slack/wee-slack

I relay it over to Emacs using https://github.com/the-kenny/weechat.el which is almost as nice as my regular IRC client.

An extensive list! I never knew about gx either, seems like that should be included in vimtutor

I can’t seems to get breakindent/showbreak to work as described, it just prepends each wrapped line with \\\… does anyone know how to get this to work?

No printers added to the list of things to remember.

Some things off the top of my head for someone who would want to remain anonymous:

• plain text files.
• laptop paid for in cash ‘user’@‘pc’ user name.
• never log onto any website or run any web searches on that laptop.
• email account created years ago over tor that has never been used.
• spend a few hours memorizing a bunch of single purpose random passwords.
• full disk encryption.
• public hotspots with no cameras.

Any other tips?

Why run mosh when you already use tmux, which can also keep your programs open?

Number 1 and Number 11 seem to be contradicting each other, but I suppose you could interpret #1 as saying “Don’t just say ‘I’ll fix it later’, but write it down.”

I tried fish shell for some time and really wanted to like it. In the end, I went back to (my tweaked out) zsh for several reasons:

• while fish’s defaults are much nicer than zsh’s, I still needed to configure a lot of things to my liking
• autocompletion doesn’t work for functions/aliases, e. g., I have gl as a function/alias for git pull, and then fish cannot autocomplete, abbreviations work, but I that irritates me
• history search doesn’t work as I expect, if I type the beginning of a command I have typed before, fish lets me autocomplete it (ctrl f), but skips it when pressing arrow up (I have patched that behavior out, but having to install my own fork on every new computer I use is too tedious for me)

I still recommend fish to people who don’t use the shell much anyway, and have a much better experience with default fish than default bash or zsh.

Given the benefits and that it’s so easy to migrate from Apache to Nginx I’m surprised this isn’t way more divergent by now. Other than legacy support slash too lazy to change, are there any pros to Apache I’m unaware of?

Seeing as I’m up this late only because I’m dealing with mitigating Kafka queue lag due to our big data team performing excessive complex queries on our OpenTSDB, this post couldn’t come across my screen at a better time, thanks! I’ll be interested in stress testing this soon. Has anyone here used this in a high-scale high-availability production environment yet?

Here’s one that I never understood, the difference between time and \time. Maybe someone can explain:

~/time-test § time ls
command ls --color=auto  0.00s user 0.00s system 0% cpu 0.002 total
~/time-test § time -v ls
zsh: command not found: -v
[2]    5943 exit 127   -v ls
-v ls  0.00s user 0.00s system 0% cpu 0.001 total
~/time-test 127 § \time -v ls
        Command being timed: "ls"
        User time (seconds): 0.00
        System time (seconds): 0.00
        Percent of CPU this job got: ?%
        Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00
        Average shared text size (kbytes): 0
        Average unshared data size (kbytes): 0
        Average stack size (kbytes): 0
        Average total size (kbytes): 0
        Maximum resident set size (kbytes): 2440
        Average resident set size (kbytes): 0
        Major (requiring I/O) page faults: 0
        Minor (reclaiming a frame) page faults: 105
        Voluntary context switches: 1
        Involuntary context switches: 0
        Swaps: 0
        File system inputs: 0
        File system outputs: 0
        Socket messages sent: 0
        Socket messages received: 0
        Signals delivered: 0
        Page size (bytes): 4096
        Exit status: 0
~/time-test § alias time
zsh: exit 1
~/time-test § type time
time is a reserved word
~/time-test § type \time
time is a reserved word

I came across this editor performance comparison earlier today, seems relevant.

https://github.com/jhallen/joes-sandbox/blob/master/editor-perf/readme.md

VS Code is at or near the very bottom for every performance test.