DEV Community: Kelly Popko

Taskwarrior: Track your TODO list from the Command Line

Kelly Popko — Thu, 09 Oct 2025 01:00:21 +0000

Taskwarrior describes itself as a 'Free and Open Source Software that tracks your TODO list from the command line'.

This post will touch on installing Taskwarrior and how to do the following:

Add a task
List tasks
Mark a task as done

Taskwarrior can be downloaded and 'built' or installed using a package manager.
See Taskwarrior’s Download page.

Mac / Homebrew users can use:

brew install task

How to use Taskwarrior

Cheat sheet


Action	Syntax	Example
Add a task	`task add "Task name/description"` (quotation marks optional)	`task add "Add unit tests to project"`
Mark a task as done	`task <task-id> done`	`task 5 done`
List tasks	`task list`	`task list`

Add a Task

❯ task add 'Research history of the One Ring'
Created task 1.

❯ task add Rally allies in Rohan and Gondor
Created task 2.

Note: We can use or omit quotation marks for the task description.

List Tasks

❯ task list

ID  Age   Due   Description                       Urg
1   9min        Research history of the One Ring  0
2   8min        Rally allies in Rohan and Gondor  0

2 tasks

Note that there is no 'Due' date and the urgency 'Urg' is set to 0.
We will look at these in an upcoming post.

Complete a Task

❯ task 1 done
Completed task 8e04e458 'Research history of the One Ring'.
Completed 1 task.

❯ task list

ID  Age   Due   Description                       Urg
1   8min        Rally allies in Rohan and Gondor  0

1 task

Observe only the 'Rally' task present, and it has an ID of 1.

Now we have enough information to use Taskwarrior as a TODO tool from the command line. Woohoo!

What would be even more helpful?

The ability to organize our tasks--by project or due date, for example.
The ability to track how long tasks and projects take.

We will look at both points in the upcoming articles.

If you do, please share in the comments your tips and workflow!

This post was inspired by the daily challenge of managing competing priorities with limited time.

Thank you to my mentor, Victor Goff (KOTP), for telling me about Timewarrior, Taskwarrior, and showing me how he uses them together.

Timewarrior: Track time from the Command Line

Kelly Popko — Sun, 21 Sep 2025 00:15:09 +0000

Timewarrior describes itself as a 'Free and Open Source Software that tracks time from the command line'.

This article will touch on installation and cover just enough here to get your feet wet.

How to start recording
How to stop recording
How to view the summary

Timewarrior can be installed manually or using a package manager.
See their Install page for options.

Mac / Homebrew users can use:

brew install timewarrior

How to use Timewarrior

Let’s say we want to track how much time we spend reading a book--Sandi Metz’s Practical Object Oriented Design in Ruby (POODR).

Start the timer

❯ timew start "Read POODR"
Tracking "Read POODR"
  Started 2025-09-18T20:08:47
  Current                  47
  Total               0:00:00

To stop the timer, we can specify the task (but we do not need to).
Timewarrior records one task at a time.

Stop the timer

❯ timew stop
Recorded "Read POODR"
  Started 2025-09-18T20:10:50
  Ended                    57
  Total               0:00:07

We can also view a summary of time spent on various items.

Get a Summary for the Day

❯ timew summary

Wk  Date        Day ID Tags Annotation    Start      End     Time    Total
W37 2025-09-18  Thu @3      Read POODR 20:08:47 20:10:32  0:01:45  0:01:45

Timewarrior is a new tool to me and there is more we can do with it.
Check out the tutorial and docs linked below.

In future posts, I will share how to use related-tool Taskwarrior, and how to use them together.

This post was inspired by the daily challenge of managing competing priorities with limited time.

Thank you to my mentor, Victor Goff (KOTP), for telling me about Timewarrior, Taskwarrior, and showing me how he uses them together.

I have only recently started using them--admittedly, too recently for me to benefit much from the reporting.
That said, the process of tracking and the flexibility--especially combined with Taskwarrior--has already been very beneficial.

Ruby Data Class: Immutability Workarounds/

Kelly Popko — Mon, 11 Aug 2025 15:59:22 +0000

This is part 3 in this series on Ruby's Data Class. Part 1 covered Syntax and part 2 compared Data with Struct.

Immutability Workarounds, Sort of

We can work (arguably) against the intent of Data in some ways.

For example, when an attribute is set to a Hash, we can update values in the hash.

ColorCounts = Data.define(:color_tally)
# => Colorcounts

screen_colors = ColorCounts.new({red: 0, blue: 0, green: 0})
# => #<data ColorCounts color_tally={:red=>0, :blue=>0, :green=>0}>

# Update a value in `color_tally`
screen_colors.color_tally[:red] += 5
# => 5

# Note that the value for  `:red` has been updated
screen_colors.color_tally
# => {:red=>5, :blue=>0, :green=>0}

We can also workaround to update a (non-frozen) string.

Example:

Person = Data.define(:name)
# => Person

me = Person.new(name: +'Popko')
# => #<data Person name="Popko">

me.name.prepend 'Kelly '
# => 'Kelly Popko'

me.name
# => 'Kelly Popko'

So we are not completely without the ability to modify or create certain workarounds.

However, when we need more flexibility or mutability, for example, we would want to choose class or something else more suited to what we need instead of trying to work around it with Data.

Conclusion

Using a Data object communicates the intent of the object to current and future collaborators.

Data is a great choice when you want to avoid a mutated value on the object coming back to haunt you.

Ruby Data Class vs Struct

Kelly Popko — Sat, 09 Aug 2025 19:58:15 +0000

This is part 2 in this series on Ruby's Data Class. Part 1 covered Syntax and part 3 explores immutability workarounds with Data.

In practice, a main difference between instances of Data and Struct is mutability:

Instances of Data are immutable*
Instances of Struct are mutable

*Mutable values passed to instances of Data remain immutable by default.

Data also has fewer (and different) 'built-in' methods than Struct.

This post explores differences in syntax and behavior between Data and Struct.

Syntax comparison: Create New Instance

Data

House = Data.define(:rooms, :area, :floors)
ranch = House.new(rooms: 5, area: 1200, floors: 1)
# => #<data House rooms=5, area=1200, floors=1>

Struct

House = Struct.new(:rooms, :area, :floors, keyword_init: true)
ranch = House.new(rooms: 5, area: 1200, floors: 1)
# => #<struct House rooms=5, area=1200, floors=1>

Mutability: Attempt to Renovate the house...

Data

House = Data.define(:rooms, :area, :floors)
ranch = House.new(rooms: 5, area: 1200, floors: 1)
# => #<data House rooms=5, area=1200, floors=1>

ranch.floors = 2
# (irb):3:in `<main>': undefined method `floors=' for an instance of House (NoMethodError)

This tells us there is no 'writer' (sometimes called "setter" in other
languages) method to use.

If we try to define a writer method on House and update that value, FrozenError is raised.

House = Data.define(:rooms, :area, :floors) do
  def floors=(quantity)
    @floors = quantity
  end
end
# => House

cottage = House.new(rooms: 5, area: 700, floors: 1)
# => #<data House rooms=5, area=700, floors=1>

cottage.floors = 2
# (irb):21:in `floors=': can't modify frozen House: #<data House rooms=5, area=700, floors=1> (FrozenError)
cottage.frozen?
# => true

What we can do with a Data object is clone it and update any of the attribute values.

House = Data.define(:rooms, :area, :floors)
cottage = House.new(rooms: 5, area: 1200, floors: 1)
# => #<data House rooms=5, area=1200, floors=1>

two_story_cottage = cottage.with(floors: 2)
# => #<data House rooms=5, area=1200, floors=2>

Struct

With Struct, we can renovate.

House = Struct.new(:rooms, :area, :floors, keyword_init: true)
ranch = House.new(rooms: 5, area: 1200, floors: 1)
# => #<struct House rooms=5, area=1200, floors=1>

ranch.floors = 2
# => 2

ranch
# => #<struct House rooms=5, area=1200, floors=2>

ranch.frozen?
# => false

Built-in Methods

Data Class

>> Data.methods(false)
=> [:define]
>> Data.instance_methods(false)
=>
[:deconstruct_keys,
 :pretty_print,
 :pretty_print_cycle,
 :deconstruct,
 :hash,
 :==,
 :inspect,
 :members,
 :to_s,
 :with,
 :eql?,
 :to_h]

Struct

>> Struct.methods(false)
=> [:new]
>> Struct.instance_methods(false)
=>
[:deconstruct_keys,
 :==,
 :members,
 :to_a,
 :to_s,
 :[],
 :[]=,
 :values_at,
 :eql?,
 :to_h,
 :select,
 :filter,
 :pretty_print,
 :pretty_print_cycle,
 :deconstruct,
 :hash,
 :inspect,
 :each_pair,
 :values,
 :length,
 :dig,
 :size,
 :each]

Comparison

>> struct_methods - data_methods
=>
[:to_a,
 :[],
 :[]=,
 :values_at,
 :select,
 :filter,
 :each_pair,
 :values,
 :length,
 :dig,
 :size,
 :each]

>> data_methods - struct_methods
=> [:with]

Ruby Data Class: Syntax

Kelly Popko — Mon, 21 Jul 2025 23:04:47 +0000

This is part 1 in this series on Ruby's Data Class. Part 2 compares Data with Struct. Part 3 explores immutability workarounds with Data.

What is the Data class?

A Ruby class to allow the definition of simple classes for value-alike objects.

Data is intended to store immutable values*.
Once defined, its instance cannot
*A future post will explore the wiggle room here.

Once defined, the instance of Data class is

A Ruby class designed to create for objects with the intention of being immutable.

The Data class was introduced to Ruby in Ruby 3.2, to:

'define simple classes for value-alike'
store immutable atomic values

When was Data brought into Ruby?

Ruby 3.2

Create the blueprint (instance of Data class)

We call Data.define and pass keyword arguments.

Book = Data.define(:title, :author, :year)

We can define methods as well if we pass it a block.

Book = Data.define(:title, :author, :year) do
  SUMMARY = '%<title>s was written by %<author>s in %<year>i.'

  def to_s
    SUMMARY % {title:, author:, year:}
  end
end

hobbit = Book.new("The Hobbit", "J.R.R. Tolkien", 1937)
puts hobbit
# => nil
'The Hobbit was written by J.R.R. Tolkien in 1937.'

Building from the blueprint

Call .new or use [] notation
Use keyword or positional arguments

`.new` + keyword arguments

hobbit = Book.new(title: "The Hobbit", author: "J. R. R. Tolkien", year: 1937)
# => <data Book title="The Hobbit", author="J. R. R. Tolkien", year=1937>

hobbit.author
# => "J. R. R. Tolkien"

hobbit.year
# => 1937

hobbit.title
# => "The Hobbit"

Bracket Notation + Positional arguments

Location = Data.define(:latitude, :longitude)
# => Location

We can use positional arguments but need to take care with the order.

philadelphia = Location[39.9526, -75.1652]
# => #<data Location latitude=39.9526, longitude=-75.1652>

philadelphia.latitude
# => 39.9526

philadelphia = Location[-75.1652, 39.9526]
# => #<data Location latitude=-75.1652, longitude=39.9526>

philadelphia.latitude
# => -75.1652

Bracket Notation + Keyword Arguments

Note that with keyword arguments, we have flexibility in the order we pass arguments.

philadelphia = Location[latitude: 39.9526, longitude:-75.1652]
# => #<data Location latitude=39.9526, longitude=-75.1652>

philadelphia.latitude
# => 39.9526

philadelphia = Location[longitude:-75.1652, latitude: 39.9526]
# => #<data Location latitude=39.9526, longitude=-75.1652>

philadelphia.latitude
# => 39.9526

IRB and `ls` to inspect object

Kelly Popko — Wed, 09 Jul 2025 00:04:35 +0000

Today I learned we can use ls to...

Show methods, constants, and variables. Ruby 3.2 Official Documentation IRB Commands

Examples

Looking at a class Greeting I created:

?> class Greeting
?>   attr_accessor :name
?>
?>   def initialize(name)
?>     self.name = name
?>   end
?>
?>   def to_s
?>     'Hello, %s' % name
?>   end
>> end
=> :to_s
>> ls Greeting
Greeting#methods: name  name=  speak  to_s
>> ls Greeting.new('foo')
Greeting#methods: name  name=  speak  to_s
instance variables: @name

Looking at a built-in Ruby class, Struct

>> ls Struct
Struct.methods: new
Struct#methods:
  ==    []    []=     deconstruct  deconstruct_keys  dig  each  each_pair  eql?  filter  hash  inspect  length  members  pretty_print  pretty_print_cycle  select  size  to_a
  to_h  to_s  values  values_at
Enumerable#methods:
  all?        any?        chain            chunk             chunk_while   collect     collect_concat  compact   count       cycle   detect      drop   drop_while  each_cons
  each_entry  each_slice  each_with_index  each_with_object  entries       filter_map  find            find_all  find_index  first   flat_map    grep   grep_v      group_by
  include?    inject      lazy             map               max           max_by      member?         min       min_by      minmax  minmax_by   none?  one?        partition
  reduce      reject      reverse_each     slice_after       slice_before  slice_when  sort            sort_by   sum         take    take_while  tally  to_set      uniq
  zip

Sources

Today I Learned: Unpack a Gem

Kelly Popko — Mon, 30 Jun 2025 15:18:40 +0000

Today I learned how to unpack a gem:

❯ gem unpack my-gem-0.0.0.gem

This creates a directory my-gem-0.0.0 we can navigate to cd my-gem-0.0.0:

❯ ls
my-gem-0.0.0
❯ cd my-gem-0.0.0

From here, we can take a look at the contents.

Example:

❯ ls
bin lib

Note: for an unknown gem, consider instead using fetch to unpack.

Sources

Developer terms: Factory

Kelly Popko — Tue, 22 Apr 2025 04:41:48 +0000

What makes an object a 'factory'?

Well, today I learned that a factory refers to:

An object whose purpose is to create other objects is a factory.... ¹ (emphasis mine)

For example:

class Book
  attr_reader :title, :author
  def initialize(title, author)
    @title  = title
    @author = author
  end
end

module BookFactory
  def self.create(title:, author:)
    Book.new(title, author)
  end
end

In this code snippet, BookFactory is a factory because its (sole) purpose is to create a new instance of Book.

S. Metz, Practical object-oriented design: An agile primer using Ruby, 2nd ed. Boston, MA: Addison-Wesley Educational, 2017. ↩

DEV Community: Kelly Popko

Taskwarrior: Track your TODO list from the Command Line

How to use Taskwarrior

Timewarrior: Track time from the Command Line

How to use Timewarrior

Ruby Data Class: Immutability Workarounds/

Immutability Workarounds, Sort of

Conclusion

Ruby Data Class vs Struct

Syntax comparison: Create New Instance

Data

Struct

Mutability: Attempt to Renovate the house...

Data

Struct

Built-in Methods

Data Class

Struct

Comparison

Ruby Data Class: Syntax

What is the Data class?

When was Data brought into Ruby?

Create the blueprint (instance of Data class)

Building from the blueprint

.new + keyword arguments

Bracket Notation + Positional arguments

Bracket Notation + Keyword Arguments

Further Reading

IRB and `ls` to inspect object

Examples

Sources

Today I Learned: Unpack a Gem

Developer terms: Factory

`.new` + keyword arguments