Darren Clark

Neopets.com Also Changed My Life

Sun, 07 Dec 2025 18:30:00 -0500

I recently stumbled upon Anna Streetman’s blog post How Neopets.com Changed My Life.

Immediately I clicked in to it, knowing I’d feel nostalgia.

My story is much like hers. Like Anna, Neopets also nudged me towards learning skills that would lead to my career.

For the uninitiated, Neopets is a browser-based game where players raise virtual pets. From Flash mini-games to a full in-game economy and social features, it had everything. And, all of this in the early 2000s. It was impressive.

But it was one feature that changed the course of my life - players could use HTML and CSS to create home pages for their pets. I was amazed at what others were able to create with HTML and CSS. I thought, like Anna, “Wow, I wish I knew how to do that.”

But that’s not all I learned. On Neopets, they allowed you to create homepages for your pets. You could write a little about them, give them a story, maybe draw some art, things of that nature. I remember looking at some of these advanced pages and thinking, “Wow, I wish I knew how to do that.”

So I learned. With the help of Neopets.com, I learned HTML, one of my more valuable skills I have today.

Anna Streetman, How Neopets.com Changed My Life

Soon after discovering HTML, my computer time quickly shifted from spending time on Neopets.com to learning everything I could on HTMLGoodies.com. That wavy orange sidebar was quickly burnt in to my memory (and my CRT monitor) forever.

The HTML led to JavaScript, which led to PHP and other programming languages. Years later, I’d land my first full-time job doing software development right out of high school.

I can’t imagine the Neopets creators had any idea the impact their game would have on people. And the Hacker News comments for Anna’s post have many more stories like ours.

Those comments show how impactful these creative outlets were to our generation.

It’s important that society continues to provide these creative outlets. Especially in today’s era of endlessly scrollable feeds and auto-playing videos.

Commands, args, and ENTRYPOINTs in Kubernetes

Sat, 19 Feb 2022 11:30:00 -0500

Perhaps one of the most perplexing parts of starting a Docker container in Kubernetes is the variety of options for specifying the command to be run.

A Dockerfile can include one or both of CMD and ENTRYPOINT instructions:

FROM alpine
CMD ["echo", "hello, world!"]

FROM alpine
ENTRYPOINT ["echo"]
CMD ["hello, world!"]

FROM alpine
ENTRYPOINT ["echo", "hello, world!"]

Similarly, Kubernetes has command and args fields:

apiVersion: v1
kind: Pod
metadata:
  name: hello-world
spec:
  containers:
  - name: hello-world
    image: alpine
    command: ["echo"]
    args: ["hello, world!"]
  restartPolicy: OnFailure

Frustratingly, the terminology doesn’t quite line up between the two:

	command	arguments
Docker	`ENTRYPOINT`	`CMD`
Kubernetes	`command`	`args`

NOTE: In the cases where command or args isn’t set, Kubernetes will use the equivalent instruction from the Dockerfile.

Both ‘command’ and ‘arguments’ are lists. As such, the ‘command’ portion can include both the executable and some arguments.

command	arguments	command run
`["echo"]`	`["hello", "world"]`	`echo hello world`
`["echo", "hello"]`	`["world"]`	`echo hello world`

Putting this to use

We can leverage these two fields to build Docker images that are easy to run locally, yet are flexible when deployed.

In our Dockerfile, we’ll use ENTRYPOINT to define the “base command” and CMD to provide a set of default options. When deploying this container, we can override the default options by specifying args in our Kubernetes manifests.

For example, here’s a Dockerfile file using Python’s bundled web server:

FROM python:3-alpine

WORKDIR /site
COPY index.html ./

ENTRYPOINT ["python3", "-m", "http.server"]
CMD ["8000"]

We can build and run this locally:

docker build -t my-python-web-server:v1 .

# uses port 8000 from the Dockerfile
docker run -it -p8000:8000 my-python-web-server:v1

# and, we can override CMD to use a different port
docker run -it -p8123:8123 my-python-web-server:v1 8123

When we deploy this to Kubernetes, we can use args to easily set a port to listen on:

NOTE: using a static Pod for brevity, usually a Deployment or similar would be used in a production environment.

# pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-python-web-server
spec:
  containers:
  - name: server
    image: my-python-web-server:v1
    args: ["8888"]

We can apply this and use kubectl’s port forwarding functionality to access our web server:

kubectl apply -f pod.yaml

kubectl port-forward pods/my-python-web-server 8888:8888

Wrapping up

By using this pattern, we’ve:

provided a set of default options to run our image locally, and
made it easy to override those defaults when running in Kubernetes

It should also be noted, this pattern works good for the above use case. There are many other uses cases for these parameters.

Copying and pasting to terminal programs on macOS

Sat, 21 Nov 2020 17:43:07 -0500

Two of my favourite shell commands on macOS are pbcopy and pbpaste.

pbcopy (“pasteboard-copy”) copies text from standard input, just like Command-C.

echo "Hello, world" | pbcopy

Similarly, pbpaste (“pasteboard-paste”) pastes the contents of the pasteboard to standard output - like Command-V.

pbpaste
# Hello, world

This is the same pasteboard the rest of macOS uses, making it easy to copy/paste text to and from GUI programs.

The real beauty of these two becomes apparent when we compose them with other tools, just like the founders of Unix intended.

Read on for some of my favourite use cases, pulled straight from my shell history.

Formatting JSON

Using jq to format JSON:

# Pasteboard before:
# {"x":1  , "y" :  2, "z":3}

pbpaste | jq . | pbcopy

# Pasteboard after:
# {
#   "x": 1,
#   "y": 2,
#   "z": 3
# }

Decoding base64

For peeking inside random base64 encoded values:

# Pasteboard:
# SGVsbG8sIHdvcmxkIQo=

pbpaste | base64 -D
# Hello, world!

Uppercasing a string

Read as:

transform - tr
all lowercase characters - '[[:lower:]]'
to uppercase - '[[:upper:]]'

# Pasteboard before:
# c600a378-2055-4f2f-82a2-fd00a6ea9629

pbpaste | tr '[[:lower:]]' '[[:upper:]]' | pbcopy

# Pasteboard after:
# C600A378-2055-4F2F-82A2-FD00A6EA9629

How long is that string?

The wc (word count) command can be used to count characters (-c), lines (-l), and of course, words (-w).

# Pasteboard contents:
# The quick brown fox jumps over the lazy dog

pbpaste | wc -w
#      9

pbpaste | wc -c
#      43

And my favourite, `x = x`

Got a bunch of pesky text formatting in your pasteboard? Want to get rid of it?

pbpaste | pbcopy

Thanks for reading! Got any novel use cases for pbcopy/pbpaste? I’d love to hear about them, I’m @darrenclark on Twitter.

How can I test Kubernetes permissions?

Sun, 15 Nov 2020 11:27:38 -0500

They say a bash one-liner is worth a thousand words, or something like that…

kubectl --as system:serviceaccount:default:myapp get pods
# Error from server (Forbidden): pods is forbidden: User 
# "system:serviceaccount:default:myapp" cannot list resource 
# "pods" in API group "" in the namespace "default"

Recently I found myself setting up a Kubernetes service account to give my application read access to some Kubernetes resources. Following the principle of least privilege, I wanted to ensure my application had the absolute minimum access it needed.

As I prepared the Kubernetes YAML files, I wondered how I could test these locally before deploying. Follow along below to see the process I used.

Setting the Stage

First, we’ll need a Kubernetes cluster to test on.

I’m going to use minikube to create a test cluster on my laptop, but any Kubernetes cluster will work.

minikube start
# 😄  minikube v1.15.0 on Darwin 10.15.5
# ✨  Automatically selected the docker driver. Other choices: hyperkit, virtualbox
# 👍  Starting control plane node minikube in cluster minikube
# .....
# 🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Meet Alice and Bob

We’ll need two test subjects (pun intended). I’ve put together a Kubernetes config that:

Creates two service accounts, alice and bob
Grants both alice and bob permissions to view Kubernetes jobs
Grants alice permissions to create new jobs

You can view the gist on Github. We’ll apply it to our Minikube cluster:

kubectl apply -f https://gist.githubusercontent.com/darrenclark/1e0810a0e864efe9bb712d3d0dd991c7/raw/83458fdf93c3aea1be292506e28a26c73e68e9db/service-accounts-and-permissions.yaml
# serviceaccount/alice created
# serviceaccount/bob created
# role.rbac.authorization.k8s.io/jobs-viewer created
# role.rbac.authorization.k8s.io/jobs-manager created
# rolebinding.rbac.authorization.k8s.io/alice-and-bob-jobs-viewer created
# rolebinding.rbac.authorization.k8s.io/alice-jobs-manager created

Testing out our permissions

Let’s test out the permissions on our newly created service accounts. Lucky for us, kubectl has the perfect tool for the job. From the man page:

    --as=""      Username to impersonate for the operation

This allows us to run kubectl as if we were alice or bob.

We can use the Job definition in this Gist to test it out.

Testing `alice`’s permissions

Let’s try creating a job with alice:

kubectl create \
  --as=system:serviceaccount:default:alice \
  -f https://gist.githubusercontent.com/darrenclark/1e0810a0e864efe9bb712d3d0dd991c7/raw/83458fdf93c3aea1be292506e28a26c73e68e9db/job.yaml
# job.batch/echo-job-jv8jh created

And viewing that job as alice:

kubectl --as=system:serviceaccount:default:alice get jobs
# NAME             COMPLETIONS   DURATION   AGE
# echo-job-jv8jh   1/1           3s         39s

No surprises here, as we granted alice read and write access to jobs.

Testing `bob`’s permissions

Next, lets try viewing the job as bob:

kubectl --as=system:serviceaccount:default:bob get jobs
# NAME             COMPLETIONS   DURATION   AGE
# echo-job-jv8jh   1/1           3s         3m25s

Looks good. What happens when we try to create a job as bob?

kubectl create \
  --as=system:serviceaccount:default:bob \
  -f https://gist.githubusercontent.com/darrenclark/1e0810a0e864efe9bb712d3d0dd991c7/raw/83458fdf93c3aea1be292506e28a26c73e68e9db/job.yaml
# Error from server (Forbidden): error when creating "https://gist.githubusercontent.com/darrenclark/1e0810a0e864efe9bb712d3d0dd991c7/raw/83458fdf93c3aea1be292506e28a26c73e68e9db/job.yaml":
# jobs.batch is forbidden: User "system:serviceaccount:default:bob" 
# cannot create resource "jobs" in API group "batch" in the namespace
# "default"

As we expected! We gave bob read-only access to jobs, so it makes sense we got an error back.

I was quite happy to learn about the --as argument. It made it really easy to test the permissions for my service account, and I could be confident I was giving it the minimum required permissions.

Coalescing Updates With Dispatch Sources

Thu, 27 Dec 2018 18:27:36 +0000

Today I wanted to look at using DispatchSourceUserDataAdd to coalesce calls to (potentially expensive) functions like UITableView.reloadData().

If you want to follow along in Xcode, feel free to copy/paste this gist into an iOS Playground.

Background

The example follows the patterns described in Apple’s documentation on Model-View-Controller.

Our “Model” layer is compromised of the TodoList and TodoListItem classes. In reaction to user input, we can mark items as completed by setting the TodoListItem.completed property to true. And, we can listen for changes by observing the TodoListItemUpdated notification.

class TodoList {
  static let shared = TodoList()

  var items: [TodoListItem] = [ /*...*/ ]

  // ...
}

extension NSNotification.Name {
  static let todoListItemUpdated = NSNotification.Name("TodoListItemUpdated")
}

class TodoListItem {
  let title: String

  var completed: Bool = false {
    didSet {
      NotificationCenter.default.post(name: .todoListItemUpdated, object: self)
    }
  }

  // ...
}

Our “Controller” layer is a subclass of UITableViewController. It gets data from our model (TodoList) and displays it in a table view.

class ViewController: UITableViewController {
  // ...

  override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return TodoList.shared.items.count
  }

  override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
    let item = TodoList.shared.items[indexPath.row]
    // configure cell ...
    return cell
  }
  
  // ...
}

When a user taps an item, we toggle its completed property.

  override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    TodoList.shared.items[indexPath.row].completed.toggle()
  }

In turn, the TodoListItem posts the TodoListItemUpdated notification, and our view controller reloads our table view, updating the UI for the user.

class ViewController: UITableViewController {

  override func viewDidLoad() {
    NotificationCenter.default.addObserver(
      self,
      selector: #selector(todoListItemUpdated),
      name: .todoListItemUpdated,
      object: nil
    )

    // ...
  }

  @objc func todoListItemUpdated() {
    tableView.reloadData()
  }

}

And everything works great. Since our ViewController observes changes to our model layer directly (via NotificationCenter), we never have to worry about our UI getting out of sync with our data.

As a convenience to our users, we decide to add a shortcut to mark all items as completed. Firstly, we update our TodoList class with a function to mark all items completed.

class TodoList {
  // ...

  func markAllAsCompleted() {
    for item in items {
      item.completed = true
    }
  }
}

And wire up a button to call markAllAsCompleted().

class ViewController: UITableViewController {
  override func viewDidLoad() {
    navigationItem.rightBarButtonItem = UIBarButtonItem(
      title: "Complete All",
      style: .plain,
      target: self,
      action: #selector(completeAll)
    )

    // ...
  }

  @objc func completeAll() {
    TodoList.shared.markAllAsCompleted()
  }

  // ...
}

Since our ViewController observes changes to our model via NotificationCenter, it automatically updates the UI in response to the user tapping the ‘Complete All’ button.

The Problem

Some of you may have already noticed one small issue.

The markAllAsCompleted() function sets completed = true on all of our TodoListItems
Each TodoListItem posts a TodoListItemUpdated notification
For each TodoListItemUpdated notification, our ViewController calls tableView.reloadData()

To confirm this, I’ve added a print statement when tableView.reloadData() is called.

Sure enough! Tapping ‘Complete All’ printed out five messages, one for each item we have.

Perhaps not a big issue if we have one, two, or even five items, but it could be if we have fifty or one hundred items. While our code is simple and fairly straightforward, we are unnecessary calling tableView.reloadData() a lot! We should take a look into this before shipping our app.

The Solution

Ideally we want to coalesce all of changes into a single call to tableView.reloadData(). Thankfully, Grand Central Dispatch provides us the perfect tool for the job - DispatchSourceUserDataAdd.

Dispatch Sources

Dispatch Sources are special objects that schedule blocks to run when certain low level events happen. For example, DispatchSourceSignal will enqueue a block on a given DispatchQueue when the current process receives certain Unix signals. As many of these are wrapped up in higher level APIs in Foundation.framework or elsewhere, it’s pretty rare to use Dispatch Sources directly. However, there are a couple Dispatch Sources that are quite useful for us:

DispatchSourceUserDataAdd
DispatchSourceUserDataOr
DispatchSourceUserDataReplace - at the time of this writing, this one isn’t documented in the Objective-C documentation

All three of these operate in roughly the same way:

They all store a UInt user data
The user data can be manipulated by us (the user of this API) via these methods (respectively):
- func add(data: UInt) - increments the user data by data
- func merge(data: UInt) - bitwise ORs the user data with data
- func replace(data: UInt) - sets the user data to data
When the user data becomes non-zero, it enqueues a block to run on a Dispatch Queue
After the block is run, the user data is set back to zero

Of particular interest to us is the fact that a block is only enqueued when the user data becomes non-zero, not each time it is updated.

Using `DispatchSourceUserDataAdd`

Despite being advertised as “low-level”, DispatchSourceUserDataAdd is fairly straightforward. First we create one via the DispatchSource.makeUserDataAddSource(queue:) function. We’ll put this in our ViewController class.

class ViewController: UITableViewController {
  let dispatchSource = DispatchSource.makeUserDataAddSource(queue: .main)
   
  // ...

Then we need to set an event handler, a.k.a. the block that will be queued when the user data becomes non-zero.

After that, we’ll call dispatchSource.resume() to “start” the dispatch source (by default, dispatch sources started in a suspended state)

class ViewController: UITableViewController {
  let dispatchSource = DispatchSource.makeUserDataAddSource(queue: .main)

  override func viewDidLoad() {

    dispatchSource.setEventHandler(handler: { [weak self] in
      print("tableView.reloadData()")
      self?.tableView.reloadData()
    })
    dispatchSource.resume()

    // ...
  }

Finally, we update our todoListItemUpdated() function to use the dispatch source instead of calling tableView.reloadData() directly.

class ViewController: UITableViewController {

  // ...

  @objc func todoListItemUpdated() {
    // Previously:
    //
    //  print("tableView.reloadData()")
    //  tableView.reloadData()

    dispatchSource.add(data: 1)
  }

Let’s give this a go in Xcode…

Perfect! Our code only called tableView.reloadData() once, despite getting five TodoListItemUpdated notifications.

Final Thoughts

I’ve put the final code up in this gist.

Before using this elsewhere in our app, we may want to extract this into an extension, base class, or even another class to make it a little more ergonomic. Rather than calling a function like add(data: 1) to signal a reloadData() is needed, it’d be much nicer to call a function named setNeedsReloadData() or similar.

Also, depending on our use cases, we might want to take a look at DispatchSourceUserDataOr. Since it combines data together via a bitwise OR, we could use a bitmask to signal different types of updates are needed, rather than doing a full reloadData() each time.

Finally, I’d encourage you to read over Apple’s Dispatch documentation, Grand Central Dispatch has quite a few interesting APIs in it.

About

Mon, 01 Jan 0001 00:00:00 +0000

I currently live and work in Toronto 🇨🇦 For much of my life I’ve been fascinated by computers, software, and programming.

I’m currently building the social network for the AI era at Kiid AI.

Before Kiid, I spent nearly ten years at theScore, working on sports media, daily fantasy, and sports betting apps. And before that, my first full time job was at Fluik, working on hit mobile games like Office Jerk.

Outside of software development, I’m passionate about the outdoors ⛰️, hiking 🥾, rec sports 🏐 🥌 and learning new things!