I live in a small town that occasionally broadcasts announcements over the radio. For the past few years, I’ve been building a small Raspberry Pi appliance to transcribe these broadcasts to text. However, there are many broadcasts that don’t contain spoken content, so I wanted a way to recognize the kind of broadcast and make a decision whether to send it to the speech-to-text service or not.
Here’s what I have right now:
The bots should announce, “I’m not a person, or if I am, I’m not allowed to act like one.”
Or, if there’s no room or time for that sentence, perhaps a simple bot at the top of the conversation. That way, we can save our human emotions for the humans who will appreciate them.
-- Truth in bots | Seth’s Blog
“If you can’t tell the difference, does it matter?”
Quacking like ducks, et cetera.
Update: Target tracking scaling is now available for ECS services.
I’ve been working on setting up autoscaling settings for ECS services recently, and here are a couple notes from managing auto-scaling for ECS services using Terraform.
min_capacity and max_capacity must both be set.schedule uses the CloudWatch schedule expression syntax, with the addition of the at(...) expression.
Terraform will perform the following actions:
+ aws_appautoscaling_scheduled_action.green_evening
id:
arn:
name: "ecs"
resource_id: "service/default-production/green"
scalable_dimension: "ecs:service:DesiredCount"
scalable_target_action.#: "1"
scalable_target_action.0.max_capacity: "20"
scalable_target_action.0.min_capacity: "2"
schedule: "cron(0 15 * * ? *)"
service_namespace: "ecs"
+ aws_appautoscaling_scheduled_action.wapi_green_morning
id:
arn:
name: "ecs"
resource_id: "service/default-production/green"
scalable_dimension: "ecs:service:DesiredCount"
scalable_target_action.#: "1"
scalable_target_action.0.max_capacity: "20"
scalable_target_action.0.min_capacity: "3"
schedule: "cron(0 23 * * ? *)"
service_namespace: "ecs"
This fails with:
I’m currently working on migrating a Rails application to ECS at work. The current system uses a heavily customized Capistrano setup that’s showing its signs, especially when deploying to more than 10 instances at once.
While patiently waiting for EKS, I decided to use ECS over manage my own Kubernetes cluster on AWS using something like kops. I was initially planning on using Lambda to create the required task definitions and update ECS services, but native CodePipeline deploy support for ECS was announced right before I started planning the project, which greatly simplified the deploy step.
A few years ago when I was doing client work, we would regularly host clients’ sites and apps for them. During this time, I was responsible for both development and keeping them up and running as much as possible. Most of the money being in new development, it was difficult to assign priority to improving the operations of existing applications. In this period, I wanted an “operations person” to teach me how to make new applications that would need minimal operations support from the beginning. Failing this, I decided to become “the operations person” myself.
We use fluentd to process and route log events from our various applications. It’s simple, safe, and flexible. With at-least-once delivery by default, log events are buffered at every step before they’re sent off to the various storage backends. However, there are some caveats with using Elasticsearch as a backend.
Currently, our setup looks something like this:
The general flow of data is from the application, to the fluentd aggregators, then to the backends – mainly Elasticsearch and S3. If a log event warrants a notification, it’s published to a SNS topic, which in turn triggers a Lambda function that sends the notification to Slack.
I recently started using Ubuntu Linux on my main development machine. That means that my PostgreSQL database is running under Ubuntu, as well. I’ve written guides to upgrading PostgreSQL using Homebrew in the past, but the upgrade process under Ubuntu was much smoother.
These steps are assuming that you use Ubuntu 16.04 LTS, and PostgreSQL 9.6 is already installed via apt.
Stop the postgresql service.
$ sudo service postgresql stop
Move the newly-created PostgreSQL 9.6 cluster elsewhere.
Here are the headline features of Sierra, and my thoughts about them.
Don’t use it on the phone, won’t use it on the Mac. It would be nice if I could use it by typing, though.
This seems like a massive security risk. It works via iCloud, so if someone (like my daughter) is using my iPad, then it will sync the clipboard to that, too. How do I turn it off?
I stumbled upon Convox a couple weeks ago, and found it pretty interesting. It’s led by a few people formerly from Heroku, and it certainly feels like it. A simple command-line interface to manage your applications on AWS, with almost no AWS-specific configuration required.
An example of how simple it is to deploy a new application:
$ cd ~/my-new-application
$ convox apps create
$ convox apps info
Name my-new-application
Status creating
Release (none)
Processes (none)
Endpoints
$ convox deploy
Deploying my-new-application
Creating tarball... OK
Uploading... 911 B / 911 B 100.00 % 0
RUNNING: tar xz
...
... wait 5-10 minutes for the ELB to be registered ...
$ convox apps info
Name my-new-application
Status running
Release RIIDWNBBXKL
Processes web
Endpoints my-new-application-web-L7URZLD-XXXXXXX.ap-northeast-1.elb.amazonaws.com:80 (web)
Now, you can access your application at that ELB specified in the “Endpoints” section.
Elixir’s Getting Started guides go over the &Module.function/arity and &(...) anonymous function shorthand, but there are a couple neat tricks that are not immediately apparent about this shorthand.
For example, you can do something like &"...".
iex> hello_fun = &"Hello, #{&1}"
iex> hello_fun.("Keita")
"Hello, Keita"
Let’s have some more fun.
iex> fun = &~r/hello #{&1}/
iex> fun.("world")
~r/hello world/
iex> fun = &~w(hello #{&1})
iex> fun.("world")
["hello", "world"]
iex> fun.("world moon mars")
["hello", "world", "moon", "mars"]
iex> fun = &if(&1, do: "ok", else: "not ok")
iex> fun.(true)
"ok"
iex> fun.(false)
"not ok"
You can even use defmodule to create an anonymous function that defines a new module.
In the beginning of 2015, I wrote a blog post about how my then-current programming language of choice (Ruby) was showing itself to not be as future-proof as I would have liked it to be.
A lot has changed since then, but a lot has remained the same.
First: I have started a few open-source Elixir projects:
The initial push to get me in to Elixir was indeed its performance, but that’s not what kept me. At the same time, I also tried learning Go and more recently, Rust has caught my attention.