What Made It So Special for Me as a Speaker?

From the moment I began preparing, the communication from Amanda and the Rails World team was exceptional. As someone who thrives on having a clear plan, I appreciated how smooth the process was—from visa requirements and accommodation details to the logistics of my speaking slot. Knowing what was expected of me helped ease any anxiety about the little things, allowing me to focus fully on my talk.

For the first time, I presented without my laptop by my side, which felt unnerving at first. However, it turned out to be liberating because not relying on my laptop allowed me to fully engage with the stage and the audience. It forced me to build confidence in my material and trust the production crew. Ultimately, the crew went above and beyond, accommodating my requests by moving screens for my comfort, ensuring my code samples were visible, and displaying my content on additional screens for the best viewing. Submitting my slides to the production crew a few weeks in advance was also something new to me, but it meant I was more prepared.

When it came to the delivery, this was my favorite delivery as of yet. I felt confident and well-versed, standing up there discussing something I’m truly passionate about—demystifying the Rails codebase. I realized just how far I’ve come since my first talk in 2012. Over the years, I’ve learned to recognize the signs of nervousness—like a higher-pitched voice or a slight tremble—but, this time, I felt calm, collected, and in control. Even when I skipped a beat, I stayed composed, a testament to how much I’ve grown as a speaker.

Afterward, I received heartwarming compliments from attendees. Many mentioned how they enjoyed learning about the internals of Rails from my talk - and how it was useful to understand the mechanics of things like associations, which they’ve been using for years. I was thrilled that my talk resonated with both beginners and senior developers alike - this was my hope going in. By focusing on patterns within the Rails codebase, I aimed to help people realize that understanding these patterns makes it easier to trace through many code paths. Hearing that people found value in my talk made all the hard work and preparation worth it.

As someone who does not enjoy being put on the spot and often dreads the post-talk Q&A, I appreciated that Rails World allowed for more personal, one-on-one discussions afterward. It was a more relaxed and insightful way to interact with the audience.

The Rails World Community and Conference Experience

As an attendee, Rails World exceeded my expectations. The sense of community stood out the most. Even if you arrived knowing no one, by the end of the conference, you would have made friends. From the Curated Connections beforehand to the well-thought-out setup and after-parties, the organizers provided many opportunities to meet new people. There was a genuine warmth in the Rails community, and it made the whole experience special.

The technical talks were another highlight, showcasing not only cutting-edge Rails 8 features but also practical topics like leveling up performance with simple code changes, therefore providing valuable insights that were immediately applicable to real-world development.

The fun didn’t stop at the talks. There were great giveaways like a Framework laptop, GitHub skateboards, and plenty of t-shirts. For the first time ever, I even won a raffle prize—a book about High Performance PostgreSQL for Rails by Andrew Atkinson, which I got signed personally. It’s been a fascinating read so far, and if you haven’t grabbed a copy yet, I highly recommend it!

One of the most memorable aspects of the event was meeting so many people I’ve interacted with online. Meeting the Rails documentation team in person was a joy, and I believe it will further improve our already good team dynamics going forward. I also connected with people that I’ve chatted to only online over the past years, and it was a great feeling to see those relationships translate from the online world to real life. To top it all off, I even met another attendee who made the journey all the way from Cape Town, South Africa—what a small world!

Final Thoughts

The hype surrounding Rails World, both at the event and on Twitter, was unmatched. The energy was palpable, with people eager to learn, share, and connect. It was an unforgettable experience, surrounded by incredibly talented developers, each contributing to the Rails community in unique and exciting ways.

When the recording of my talk is released, I’ll add the link here, but in the meantime, feel free to check out my slides. I can only grow as a speaker with your help - if you attended my talk, I’d appreciate hearing your thoughts on my content and delivery, you can share your feedback on this form!

Overall, Rails World 2024 was an unforgettable experience, and I’m excited to see how the Rails community continues to grow and evolve. I left Toronto feeling inspired, energized, and ready to apply what I learned—not just to my projects but also in contributing further to the Rails ecosystem.

My first keynote ever! Pycon Balkan in Serbia was the first Pycon conference of its kind in the Balkan area, and it was one of the most well-organised and fun conferences that I’ve attended thus far.

I’m grateful to Pycon Balkan for giving me the opportunity to share my learnings through my keynote. The preparation for the keynote was really intense, especially because I was giving three other talks around this time. However, I feel like I've improved beyond my expectations because of this experience. My public speaking skills have come a long way, some of the more noticeable improvements have beeen that I no longer feel extremely anxious before a talk, which means that there’s no longer a slight tremor in my voice. I am able to control my pace and pitch, and I’m learning to control my posture as well. However, the way that I've impressed myself most was my ability to sip water whilst talking :P. All in all, I really enjoy the entire process. The talk link isn’t up as yet, but as soon as it’s released I’ll update and link to it.

Not only was the speaking aspect great, but I also had the opportunity to meet wonderful and interesting people on this journey. During this time, I also experienced my coldest winter in Europe (some truly hibernating worthy temperatures for a South African) with just a touch of snow which was magical.

Being recognised as one of the fifty inspiring women in South Africa has been my greatest honor this year.

InspiringFifty is a non-profit that aims to increase diversity in tech by making female role models in tech more visible. The Inspiring Fifty women are role models for encouraging more girls and women in technology, as well as inspiring future leaders and entrepreneurs to follow in their footsteps. You can read more about it here .

I was truly humbled by this award. Looking at the profiles of all fifty women made me realise that there are so many other women out there that are championing through their industries, leading, inspiring and making a difference. The energy, motivation and ambition of these women is contagious and extremely motivating!

I hope to continue making a difference in this industry in every way that I possibly can.

The Kasi Maths program’s one year anniversary. Kasi Maths aims to help students from previously disadvantaged schools to develop mathematical skills, gain confidence in their mathematical abilities, and increase their enjoyment of mathematics. In the long term Kasi Maths wants to help students to pass mathematics at a Grade 12 level and take up STEM courses at a tertiary level.

Kasi Maths has been particularly rewarding because I feel like I am making a direct impact to the students that attend the program. Just like Inspiring fifty, the program has made me realise that there are people out there that simply want to help to make a difference. This program would not be possible without the help from our dedicated volunteers who give up their Mondays and Wednesdays to assist the learners. The learners that attend are motivated, intelligent and ambitious boys and girls that have made it their mission to improve and do better at school, and do something with their lives irrespective of their circumstances.

As for me, Kasi Maths has been one of the more difficult endeavours that I’ve undertaken and its been a rocky year for the team. We’re still finding our feet and figuring out what’s the best way to do things, we’re learning slowly and surely we’ll get there with the help of volunteers, partners and schools.

Co-organising meetups like Women In Tech, Ladies that UX and Railsbridge - These three meet-ups have allowed me to explore different domains of the technology area, meet interesting people, and learn and share with others. Being a co-organiser has given me a sense of appreciation of how much effort and work goes into preparing for a meet up, and I have a newfound sense of gratitude to other organisers who put events together.

Through Women In Tech, I’ve been able to interact with women and men in the industry who are passionate about technology as well as diversity within the industry. LTUX has been the meet up that has given me the most perspective this year. Through this initiative, I’ve learnt so much about user experience and how our decisions as developers can lead to seamless journeys for users which ultimately plays a huge role in the success of an application. It has also allowed me to interact with designers and user experience experts on a new level. Being one of the few software developers at these meet-ups, I’ve come to realise that there are many gaps and challenges in the interaction between designers and developers that we need to bridge. Finally, the last workshop that I co-organised was a RailsBridge workshop. These workshops are free and fun ways to get started or level up with Rails, Ruby, and other web technologies. Railsbridge workshops remind me of the struggles that I encountered when I was still learning to code and for me, it emphasises the importance of mentorship, especially since so many aspects of software development can be overwhelming and frustrating.

Finally, one of the most difficult decisions I’ve made this year was resigning as a director and employee of Zero One. I had co-founded Zero One in 2015 and helped build this software company through hard-work and dedication. I resigned because I had realized that my happiness lies in a different direction, and for the longest time it has been challenging to put my happiness above my attachment to a company that I’ve seen grow from strength to strength over the years. Through my journey with Zero One I’ve embraced my entrepreneurial spirit, nurtured my confidence, and expanded my relationships. I no longer am just a software developer but I am someone who cares deeply about building products in a manner that allows for sustainability, scalability, and adaptability. I’ve learnt to care about clients and end users, and instead of distancing myself from them, I collaborate with them to build products that are useful. I’ve worked with multiple clients over years through Zero One and I’ll forever be grateful for the learnings that I took away from working with each client. Some of these learning were more technical like architecture and design practices, whilst others were about project design, management, and scope. I’ve also learnt about good team dynamics, team motivation, and effective communication. I’ll use these learnings throughout my life in all that I do.

This year has been rewarding and fulfilling in many ways, its also been exhausting with very little balance and time to myself. I’m most grateful that I feel like with each year through all the different things that I try, I’m closer to understanding and learning more about myself. In its simplest form this year I learnt:

• The value of being able to communicate effectively
• Software development is not only about the technology but there are so many other aspects to creating a good product.
• On a more personal level - to be detach myself emotionally from draining situations that are not to my expectations and not within my control. It's still a work in progress but I’m slowly but surely getting there.

I’m glad for the support system that I’ve had, in particular, the friends and family that have helped me through difficult periods this year.

I look forward to 2019 with new resolutions and hopefully a new energy. In 2019 I’d like to work towards:

• More speaking opportunities that allow me to learn and share and meet new people in South Africa and abroad all aligned in trying to learn, share and make a difference through technology.
• A more healthy way of living - gym, good eating habits and some balance in my life.
• As fun as it was doing all these amazing things in 2018, I’ve realised that I’m not very good at saying no to new endeavours. Whilst this has had its perks over the years, it has left me feeling overwhelmed and exhausted for months on end. This year I want to focus on the things that I am extremely passionate about and that I can truly make a difference towards.
• Tech Tech and more tech. As always I want to continue learning as tech constantly evolves. However, I'd like to have more focussed learning.
• Expanding the Kasi Maths program to help more students and to run sustainably. This means getting out of my comfort zone and reaching out to partners and volunteers.

With that being said - Wishing you all a successful and happy 2019!

For this reason, I chose create-react-app to give me the most simplest folder structure with the bare necessities to get up and running.

The first step is to install create-react-app. This can be done by following the documentation for create-react-app. It simply asks you to do the following to get started:

$ npm install -g create-react-app
$ create-react-app my-app
$ cd my-app

You will also need to ensure that you have a dependency management tool installed in order to install any dependancies that you may require to develop your app. My dependency manager of choice at the moment is yarn.

To install yarn, follow the yarn documentation, however if you using a mac it will be as simple as executing

$ brew install yarn

Once you have yarn installed, you can start your server by running:

$ yarn start

Thereafter navigate to http://localhost:3000/ to see your application.

What are we building?

We’re going to start off with a basic app that contains a header and a main component that will render static data.

Creating our header and main components

Once you’ve generated the react app, navigate to your app directory and let the fun begin!

In order to edit your home page navigate to src/App.js. You’ll notice that this is the component that gets rendered when you start up your server. We know this because in the index.js we see the following code which indicates that the index route renders the App component.

ReactDOM.render(<App/>, document.getElementById('root'));

We’re going to amend the component slightly to start building out the layout for our application. Most applications, always contain a header and a main container. So, lets start by editing the App.js to create a header and main container. We’ll be replacing the code in the render method within the App.js file to achieve our goal.

Lets start by removing the static text that create-react-app has generated for us, to make our component look more like this:

src/App.js

import React from 'react';
import logo from './logo.svg';
import './App.css';

class App extends React.Component {
  render() {
    return (
      /* remove code here */
    )
  }
}

export default App;

You’ll notice above that our App extends React.Component, which we import from the React package in the first line of the file.

React has introduced a simpler way to define stateless components using plain Javascript ES2015 syntax (read the ffg article to understand the advantages of using this syntax instead of the class definition when working with stateless components.

Since we don’t expect our Header to contain any state at the moment, we can define our header as a stateless component:

src/App.js

const Header = () => (
  <header>
    <nav>
      <ul>
        <li>Home</li>
        <li>Store</li>
      </ul>
    </nav>
  </header>
)

The above code is simply a function that returns markup. The markup contains two navigation elements which we will link to in the next post when we introduce react router.

We can follow the same pattern for the Main Component. Please note, that it is a good practice utilise the stateless components only until such time when whereby there is no need to introduce state into a component. Thereafter we will be required to use a class that extends React.Component.

src/App.js

const Main = () => (
  Welcome to your first react app!
)

Now that we have defined these two components, we can reference them within our App component, so that they render when we navigate to the index route.

We render them by referencing the components inside the App components render function. <Header \> is the jsx syntax we use to reference the Header Component.

src/App.js

class App extends React.Component {
  render() {
    return (
      <div>
       <Header/>
       <Main/>
      </div>
    )
  }
}
export default App;

Notice how we encompass the two components into a div, this is because React enforces that adjacent JSX elements must be wrapped in an enclosing tag. This ensures that we are only returning one element from our render function, thus ensuring that our jsx code gets transformed correctly.

All these components that we have defined can be simply placed in the App.js file for now. In a future post, we will discuss, importing files and folder structures.

For the code related to the post please see this JSBin

Background

This particular sidebar contains the following challenges:

• It contains a nested ui and data structure, three levels deep to be exact
• It requires ajax (or in my case Ember asynchronous calls) to three separate endpoints to receive the data (promises are the way to go to solve this issue)
• Lastly, and most importantly it requires a search input.

Now, usually search inputs are pretty easy right? Most definitely, but more so when they are implemented on a flat structure. However, my search is implemented on a tree structure, which in turn means that I need to give the user experience special consideration. To elaborate, if I search for a match on a word that is nested two levels deep on one path of a tree, and three level deeps on another path of the tree, I want the user to be able to see the path leading up to the matching keyword, as well be able see the the matched word being highlighted.

After much frustration, my team and I discovered a very feature filled jsTree jquery plugin. And as a bonus, I found an ember addon that wrapped the jquery plugin, and was perfect for my Ember project.

Now, ofcourse I did my mandatory checks on the ember addon, these include:

• is it being maintained? (i.e. when was the last commit and are issues being addressed on the github repo)
• is the addon being used? (i.e the stats on the npm package )

I use these checks to determine whether I would receive the authors assistance should I encounter any issues, and also whether this addon would match any updates to Ember, and…… This addon passed the test!

The author of this addon provides some good documentation on the features exposed through the addon that map to the initial jquery jsTree plugin, as well as some examples. Like with every addon, I use the docs to come up with a solution to solve my unique problem onhand. The capabilities of this addon turns out to be numerous, there is support for features like searching, state management, drag and drop, checkboxes, etc.,all on tree structures. However, for the introductory purposes of this post, I’ll simply concentrate on rendering a tree and providing the user with the ability to search that tree whilst utilising some actions and events.

As mentioned above, the tree will contain a three level deep structure. It will contain companies at the root level, head-offices at level two, and branches at level three.

Lets get started!

Installation

In order to use this ember addon, we install it using:

$ ember install ember-cli-jstree

This will add the necessary npm and bower packages to our Ember app. (note for newbies: restart your server after the installation is necessary).

Once installed we have access to a ember-js-tree helper/component. As the author mentions, the bare minimum required in order to configure a tree structure is to pass through the data attribute to the helper.

Creating a tree structure with json data

ember-js-tree requires a very specific format to work with JSON. We define our root level nodes (i.e in our example ‘companies’) at the top level in the array.

[
  { 'text': 'Company 1' },
  { 'text': 'Company 2' }
]

In order to add children for the root level nodes, we then expand the object to contain a key called children with the array of children nodes (at a second level nesting) which will serve as the ‘headoffice’ for each ‘company’.

[
  { "text": "Company 1",
    "children": [
      { "text" : "Headoffice"}
    ]
  },
  { "text": "Company 2",
    "children": [
      {"text": "Headoffice" }
    ]
  }
]

In the above example Company 1 and Company 2 contain one headoffice each. We then apply the same concept to provide a third level of nesting which is to map out the branches that are contained under each headoffice.

[
  { "text": "Company 1",
    "children": [
      { "text" : "Headoffice",
        "children": [
          { "text" : "Branch 1" },
          { "text" : "Branch 2" },
        ]
      },
    ]
  },
  { "text": "Company 2",
    "children": [
      {"text": "Headoffice" }
    ]
  }
]

In the illustration above, Headoffice for Company 1 has two branches i.e Branch 1 and Branch 2, whilst Company 2 has no branches.

Now that we’ve figured out how our data will look, we need to set the data attribute in on our Ember Controller so that we can pass our data to the ember-js-tree helper.

controllers/application.js

import Ember from 'ember';

export default Ember.Controller.extend({
  data: [
    { "text": "Company 1",
      "children": [
        { "text" : "Headoffice",
          "children": [
            { "text" : "Branch 1" },
            { "text" : "Branch 2" },
          ]
        },
      ]
    },
    { "text": "Company 2",
      "children": [
        {"text": "Headoffice" }
      ]
    }
  ]
})

Furthermore, ember-js-tree allows you to expose a state object to determine whether a particular node should be open, disabled, or selected. As an example, in order to open one of the root nodes (‘Company 1’) we add a state object on the root node containing the opened attribute set to true.

We are also able to set any additional attributes in the JSON through a_attr, as well as set our own custom id’s at each node instead of using the default generated ember-js-tree one.

controllers/application.js

import Ember from 'ember';

export default Ember.Controller.extend({
  data: [
	  {
      'text': 'Company 1',
	  	'id': 'company-1',
	    'state': {
	      'opened': true
	    },
	    'a_attr': {
	      'people': 100
	    },
	    'children': [
	      { 'text' : 'Headoffice',
	        'children': [
	          { 'text' : 'Branch 1' },
	          { 'text' : 'Branch 2' },
	        ]
	      }
	    ]
	  },
	  { 'text': 'Company 2',
	    'children': [
	      {'text': 'Headoffice' }
	    ]
	  }
	]

Once we have set a data property on the controller (or perhaps in the model since controllers may be deprecated in Ember), we can then pass the data attribute to ember-js-tree to render.

templates/application.hbs

  {{ember-jstree
     data=data
  }}

And, voila!, just like that (very simply) we have our tree structure. Now that we have our data, the real ease of use comes in play with the search functionality.

Using the search plugin

Integrating the search plugin is extremely straight-forward. We simply send through an intent to use the search plugin to the helper, and if required we can attach some searchOptions.

We also need to create our search input and provide it with an empty/default value.

controllers/application.js

import Ember from 'ember';

export default Ember.Controller.extend({
  searchTerm: '',
  plugins: 'search',
  searchOptions: {
    'show_only_matches' : true
  },

  data: [
  ....
  ]

})

templates/application.hbs

<div class="ui icon input input--sidebar-clone__search">
  {{input type="text" placeholder="Search" class="prompt search-input form-control" value=searchTerm}}
  <i class="search icon"></i>
</div>

{{ember-jstree
   data          = data
   plugins       = plugins
   searchOptions = searchOptions
   searchTerm    = searchTerm
}}

Calling events

Now, that we have our tree setup and we’re able to search, we might want to use events to determine when a node is opened or closed. We can find a list of events in the documentation for the addon.

To illustrate events, when a user clicks on a node to open it, we will just show an alert message. In order to do so, we’d need to use the event eventDidOpen. We pass this event to our ember-js-tree helper and provide a callback for it as follows:

templates/application.hbs

<div class="ui icon input">
  {{input type="text" placeholder="Search" class="prompt search-input form-control" value=searchTerm}}
  <i class="search icon"></i>
</div>

{{ember-jstree
  data                = data
  plugins             = plugins
  searchOptions       = searchOptions
  searchTerm          = searchTerm
  eventDidOpen        = 'handleJstreeEventDidOpen'
}}

controller/application.js

import Ember from 'ember';

export default Ember.Controller.extend({
  ....

  actions: {
    handleJstreeEventDidOpen(e, data) {
      alert('opened node');
    }
  }
})

Sending actions

Sometimes we may want to manually send an action to the tree to tell it to execute on behalf of the user. As an example, we may want a button on the interface to allow the user to close all nodes instead of him/her having to manually go through each node to close them.

We do this by using the actionReceiver property and sending along the intended action.

We need to register the action receiver on the plugin by setting the actionReceiver property on the helper, and thereafter referance the corresponding ember action closeAllNodes from the button click as follows:

templates/application.hbs

<div class="ui icon input input--sidebar-clone__search">
  {{input type="text" placeholder="Search" class="prompt search-input form-control" value=searchTerm}}
  <i class="search icon"></i>
</div>

{{ember-jstree
  data                = data
  plugins             = plugins
  searchOptions       = searchOptions
  searchTerm          = searchTerm
  eventDidOpen        = 'handleJstreeEventDidOpen'
  actionReceiver      = jstreeActionReceiver
}}

<button {{action 'closeAllNodes'}}>Close all nodes</button>

controller/application.js

import Ember from 'ember';

export default Ember.Controller.extend({

  .....

  actions: {
    handleJstreeEventDidOpen(e, data) {
       alert('opened node');
    },

    closeAllNodes() {
      this.get('jstreeActionReceiver').send('closeAll');
    }
  }
})

When clicking on the button, all nodes in the tree that were open will then be automatically closed.

In conclusion, I hope that this post is useful in terms of providing you with an idea on how to use the ember addon. This was simply an introduction to the addon, but a lot more is possible in terms of styling the tree and providing additional functionality. Please find all code for this post on this Ember Twiddle.

I’d like to thank the author for this great ember addon which has made my life so much easier, and my pairing partner Micheal who worked with me in order to integrate this setup.

With all the joy that comes from programming, there is bound to be some side-effects. Some of these known side effects are:

• extreme hair pulling (now you know the secret of the developer beard),
• mood-swings depending on how well your code for the day is going (caution: this could result in your spouse making you sleep on the couch for the night),
• feeling overwhelmed (yet, so very satisfied once you’ve realised that you’ve totally rocked that code),
• and the list goes on..

Being a developer has made me realise that my day can be like a roller coaster if I do not ensure structure.The number one change you can introduce to bring some order to that chaos is time management. Time management is extremely essential to ensuring productivity. Hence, I’d like to share some techniques that I use as often as possible to assist in making me more effective.

The Pomodoro technique is the secret weapon that gives structure to my day. I basically use a timer to break down work into intervals that are traditionally 25 minutes in length, separated by short breaks. The idea is that short periods of time yield higher focus and small, frequent breaks can improve mental agility.

There are 5 basic steps in the process:

• Decide on the task to be done
• Set the pomodoro timer to 25 minutes
• Work on the task until the timer rings
• Take a short break for 3–5 minutes.
• After four pomodori, take a longer break of 15–30 minutes. (Yes, we looked it up, the plural of pomodoro is pomodori)

The Pomodoro technique keeps me aware of the time passing, and assists in minimizing distractions that could lead me into non-productive Yak-shaving sessions. Personal time-boxing is said to help curb perfectionist tendencies until the appropriate time. It allows me as a developer to concentrate on the task at hand and steadily work towards an end goal. An app that I recommend using is Eggscellent. It is a visual, integrated and customisable tool that works beautifully.

In conclusion, time is not a fungible resource and unless managed correctly, can lead to a dissatisfaction in all aspects of ones life. The Pomodoro technique is mainly known for its ability in helping one keep focused and providing a systematic way to tackle daily tasks. For me, this technique was, and continues to be, a life-changer.

With all the joy that comes from programming, there is bound to be some side-effects. Some of these known side effects are:

• extreme hair pulling (now you know the secret of the developer beard),
• mood-swings depending on how well your code for the day is going (caution: this could result in your spouse making you sleep on the couch for the night),
• feeling overwhelmed (yet, so very satisfied once you’ve realised that you’ve totally rocked that code),
• and the list goes on..

Being a developer has made me realise that my day can be like a roller coaster if I do not ensure structure.The number one change you can introduce to bring some order to that chaos is time management. Time management is extremely essential to ensuring productivity. Hence, I’d like to share some techniques that I use as often as possible to assist in making me more effective.

The Pomodoro technique is the secret weapon that gives structure to my day. I basically use a timer to break down work into intervals that are traditionally 25 minutes in length, separated by short breaks. The idea is that short periods of time yield higher focus and small, frequent breaks can improve mental agility.

There are 5 basic steps in the process:

• Decide on the task to be done
• Set the pomodoro timer to 25 minutes
• Work on the task until the timer rings
• Take a short break for 3–5 minutes.
• After four pomodori, take a longer break of 15–30 minutes. (Yes, we looked it up, the plural of pomodoro is pomodori)

The Pomodoro technique keeps me aware of the time passing, and assists in minimizing distractions that could lead me into non-productive Yak-shaving sessions. Personal time-boxing is said to help curb perfectionist tendencies until the appropriate time. It allows me as a developer to concentrate on the task at hand and steadily work towards an end goal. An app that I recommend using is Eggscellent. It is a visual, integrated and customisable tool that works beautifully.

In conclusion, time is not a fungible resource and unless managed correctly, can lead to a dissatisfaction in all aspects of ones life. The Pomodoro technique is mainly known for its ability in helping one keep focused and providing a systematic way to tackle daily tasks. For me, this technique was, and continues to be, a life-changer.