Simple Language Agnostic Emacs IDE

Fri, 02 Sep 2022 00:00:00 +0000

A lot of people are jumping in the LSP ship for their all-purpose IDE, which is fine but LSP has never been friendly to me. I always ended up having problems with something. This led me to build a minimal but very helpful setup that will work for many of the most used languages (Python/Javascript/Java/C++/etc).

I wanted an IDE setup within emacs that didn’t involve LSP or any other server because I kept running into problems and maintaining multiple servers for each language is a hassle. After searching for a bit I came into the following packages/libraries that have helped that transition to a simple but powerful IDE.

Here they are:

The reasoning for the following are below:

Projectile: This is a project management and navigation package. Think of it as your sidebar view of files in a typical IDE plus the ability to run commands on the entire project.
Dumbjump: This is arguably the most essential feature, the ability to jump to definition. This package is nicely well-written and works amazingly. Best of all, works on all major languages and has no dependencies.
Company Mode: This is what I use for auto code completion. It’s not hooked up to an engine but instead, it simply re-uses words that I’ve used throughout any buffers I’ve opened. It’s a “smart” dumb auto-code completion. Works for my purpose
GUD: Built-in debugger library in emacs. It comes with a few debuggers such as pdb which I’m constantly using. It will probably come with the debugger you need. If not, then it might be worth checking out https://github.com/realgud/realgud.

How To Be A Kind Engineer

Thu, 18 Nov 2021 00:00:00 +0000

As I’ve worked in tech, I’ve come to appreciate when engineers are considerate of other engineers. (If you’re a junior engineer reading this, I implore you to do all this and you will stand out)

Here are a few things that in my mind, make an engineer “kind”:

Meaningful Git Messages

To me, a meaningful git message is something that has 2 (possibly 3 things). Below is an example:

[BET-335] Implement caching on expensive user operations

Here are two things:

The message has the ticket ID ([BET-335]) which you can refer to for more details on the work. This can be for example the unique Jira slug of the ticket. Always include it
A clear concise message that says what this commit contains and the purpose of the changes
Not shown here, but in commit messages you are allowed to add extra text to describe more in detail about the changes made.

For better guidance, read this which was my starting point: https://chris.beams.io/posts/git-commit/

To The Point Messages

One thing that I greatly dislike is when someone sends me a message via Slack with nothing relevant or missing information. eg, hey! (followed by more lines entered one by one) page is not working (very vague, which page?)

I’m pretty sure everyone has seen the examples above from someone in their company. Not pretty nice, and greatly distracting if I’m in deep thought.

Here’s how I approach it (still figuring out what I like best but here’s what I got so far):

Hey PERSON, I'm working on JIRA-123 ticket and I've ran into some roadblocks with the database.

Problem:
DB is not populating from fixtures

What I've tried:
- Restarting DB
- Walking in circles
- Make a sacrafice to the gods

Ask:
Can we pair up once you are free or can you refer me to someone who might know the fix? thx!

This is generally the format I go with, give everything in one go, with different sections and info. I find it easier to read and would love for someone to send me messages like this. (No one has -_-) Also, the Jira ticket is usually linked to the actual ticket for easy access.

For some guidance, and ideas on messaging etiquette read this: https://slack.com/intl/en-gb/blog/collaboration/etiquette-tips-in-slack

Always lint/format before push

I’m surprised when I see commits/PRs failing because they didn’t pass the linter/formatter check. This can be easily avoided if we all ran our linters before committing (git hooks anyone?) These tools are here to make it more readable/easier to digest when reviewing.

Also, if you have something like GitHub that comments wherever linter/formatter violations occurred in your PR, then it gets really hard to review with a wall of linter errors in the way

Document your own PR

When creating a PR, please:

Properly describe what your changes are doing (Write as much as you need)
Link to the Bug tracker issue
How to test your changes (if applicable)

For your PR code, please take your time to review and:

Ask any questions you have, don’t wait for someone to point them out or hope they don’t catch it

If you were unsure about the changes you made (eg not sure if calling expensive func or something is a good idea) then please comment about asking for feedback. Don’t expect someone to catch and start a conversation, or even worse your changes go out to production and break something, all because you didn’t take the initiative.
Highlight any relevant parts of a file

Sometimes we have ‘noise’ in PRs such as indentation changes which mask the real purpose of the changes. When this happens I usually comment at the top of the file A lot of noise due to indentation changes, please see comments inside file for relevant changes Then I go to each of my actual changes and say relevant bit, doing x,y z here

Document your (and someone else’s) code

When a codebase grows to a certain size, it’s hard to maintain, especially with all the due dates and what not’s. Cause of that, I’ve come to love/hate a few things but for now, I’ll mainly talk about comments.

Love them when they are right.

Hate them when they are missing, or even worse, when they have the wrong information.

Thanks to this, I always try to make sure I document anything I’m working on that isn’t obvious at first glance. And to update wrong or missing comments. I’ve been bitten before by being too trusting at what a piece of code does from just reading the comments, and then I’m stuck wondering why it’s not working. Please comment on your code, and update any outdated ones that you see in the wild. Other devs and I will thank you in spirit.

Be considerate

Everyone should strive to be kind.

Creating new columns in Org agenda

Wed, 28 Apr 2021 00:00:00 +0000

Whenever viewing the Org agenda, you can add new “columns” to the view with the help of the org-agenda-prefix-format variable. If you do a simple C-h v org-agenda-prefix-format in emacs, you should get a nice description of what it does and how to use it.

Here is an example on how to extend it

;; Originally from here: https://stackoverflow.com/a/59001859/2178312
(defun gopar/get-schedule-or-deadline-if-available ()
  "Return an calendar emoji if current item doens't have a schedule or deadline.
  Otherwise return an empty string."
  (let ((scheduled (org-get-scheduled-time (point)))
        (deadline (org-get-deadline-time (point))))
    (if (not (or scheduled deadline))
        (format " ")
      "   ")))

(org-agenda-prefix-format
   '((agenda . " %i %-12:c%?-12t% s")
     (todo . " %i %-10:c %-5e %(gopar/get-schedule-or-deadline-if-available)")
     (tags . " %i %-12:c")
     (search . " %i %-12:c")))

In a nutshell, if I have a TODO item that doesn’t have a schedule or deadline, then I’ll add a display a simple calendar emoji, otherwise I’ll just leave some space (To emulate it being empty, otherwise the spacing gets out of sync)

I also made it so that it displays the effort.

Heres a screenshot of how it looks (I use a black/white theme):

As you can see, I have 2 thigs that don’t have a schedule/deadline and 2 of them show the estimated time it would take to complete them.

Combining react-hook-form with Draft-JS WYSIWYG

Sat, 10 Apr 2021 00:00:00 +0000

We use react-hook-form at work, and we needed to integrate it with the React Draft WYSIWYG editor. Ended up creating something like this (which requires another small 3rd party lib draft-to-html):

import React from 'react';
import PropTypes from 'prop-types';
import { Controller } from 'react-hook-form/dist/index.ie11';
import { Editor } from 'react-draft-wysiwyg';
import draftToHtml from 'draftjs-to-html';
import 'react-draft-wysiwyg/dist/react-draft-wysiwyg.css';

/**
 * Given an html string.
 * Return an `EditorState` object that is used for the Rich Editor Text Box.
 *
 */

export const getEditorState = (name) => {
  const { contentBlocks, entityMap } = htmlToDraft(name || '');
  const contentState = ContentState.createFromBlockArray(contentBlocks, entityMap);
  return EditorState.createWithContent(contentState);
};

const EMPTY_VALUE_TO_PACIFY_WARNINGS = '';

/**
 * Component that provides basic Rich Text Editor.
 */
const RichEditor = ({ name, onUpdate }) => (
  <Controller
    name={name}
    defaultValue={EMPTY_VALUE_TO_PACIFY_WARNINGS}
    render={({ onChange, value }) => {
      let defaultEditorState;
      if (defaultValue || value) {
        defaultEditorState = getEditorState(defaultValue || value);
      }

      const onInternalChange = (currentContentState) => {
        const html = draftToHtml(currentContentState);
        onChange(html);
        if (onUpdate) onUpdate(html);
      };

      const toolbar = {
        options: ['inline', 'blockType', 'list'],
        inline: {
          inDropdown: false,
          className: undefined,
          component: undefined,
          dropdownClassName: undefined,
          options: ['bold', 'italic', 'underline', 'strikethrough'],
        },
        blockType: {
          inDropdown: true,
          options: ['Normal', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6'],
        },
        list: {
          inDrodown: false,
          options: ['unordered', 'ordered'],
        },
      }

      const editorStyle = { border: '1px solid #565c65', height: '10rem' }

      return (
        <Editor
          tabIndex="0"
          spellCheck
          defaultEditorState={defaultEditorState}
          onChange={onInternalChange}
          editorStyle={editorStyle}
          toolbar={toolbar}
        />
      );
    }}
  />
);

RichEditor.propTypes = {
  name: PropTypes.string.isRequired,
  onUpdate: PropTypes.func,
};

RichEditor.defaultProps = {
  onUpdate: undefined,
};

export default RichEditor;

This works nicely and we use it in within FormContext (that is part of react-hook-form).

That’s pretty much it.

Extending Eshell Git Prompt To Provide Virtualenv Info

Thu, 17 Dec 2020 00:00:00 +0000

There’s a package that customizes your eshell prompt, it’s called eshell-git-prompt. Its pretty awesome except it doesn’t show which virtualenv I’m in, which is a big no no for me. So I ended up creating a different prompt from one of the provided ones in the package.

Before I show the code, it’s important to know that I’m using virtualenvwrapper to know which virtualenv I’m currently in, therefore a dependency.

Here’s basically what I added to the powerline prompt theme

(when venv-current-name
       (concat
        (with-read-only-face venv-current-name
          :background "#5B3758")
        (with-read-only-face segment-separator
          :foreground "#5B3758"
          :background (face-background 'eshell-git-prompt-powerline-dir-face))))

Small snippet to inject :)

Anyways, here’s how it all looks together:

;;; An extension of 'powerline' theme from `eshell-git-prompt`

(defmacro with-read-only-face (str &rest properties)
  "Add face PROPERTIES to STR."
  (declare (indent 1))
  `(propertize ,str 'face (list ,@properties) 'read-only t 'rear-nonsticky '(read-only)))

(defun eshell-git-prompt-powerline-venv ()
  (let ((segment-separator "\xe0b0")
        (branch            "\xe0a0")
        (detached          "\x27a6")
        (cross             "\x2718")
        dir git git-face)
    (setq dir
          (propertize
           (concat
            " "
            (unless (eshell-git-prompt-exit-success-p)
              (concat cross " "))
            (eshell-git-prompt-powerline-dir)
            " ")
           'face 'eshell-git-prompt-powerline-dir-face 'read-only t))
    (setq git
          (when (eshell-git-prompt--git-root-dir)
            (setq git-face
                  (if (eshell-git-prompt--collect-status)
                      'eshell-git-prompt-powerline-not-clean-face
                    'eshell-git-prompt-powerline-clean-face))
            (setq eshell-git-prompt-branch-name (eshell-git-prompt--branch-name))
            (propertize
                (concat " "
                        (-if-let (branch-name eshell-git-prompt-branch-name)
                            (concat branch " " branch-name)
                          (concat detached " "(eshell-git-prompt--commit-short-sha)))
                        " ")
              'face git-face 'read-only t)))
    (concat
     ;; This is the actuall important stuff, everthing else is the same
     (when venv-current-name
       (concat
        (with-read-only-face venv-current-name
          :background "#5B3758")
        (with-read-only-face segment-separator
          :foreground "#5B3758"
          :background (face-background 'eshell-git-prompt-powerline-dir-face))))
     (if git
         (concat dir
                 (with-read-only-face segment-separator
                   :foreground (face-background 'eshell-git-prompt-powerline-dir-face)
                   :background (face-background git-face))
                 git
                 (with-read-only-face segment-separator
                   :foreground (face-background git-face)))
       (concat dir
               (with-read-only-face segment-separator
                 :foreground (face-background 'eshell-git-prompt-powerline-dir-face))))
     (with-read-only-face (concat "\n" segment-separator)
       :foreground (face-background 'eshell-git-prompt-powerline-dir-face))
     (propertize "$" 'invisible t 'read-only t)
     (with-read-only-face " "))))

(defconst eshell-git-prompt-powerline-venv-regexp "^[^$\n]*\\\$ ")

(provide 'powerline-with-venv)

I put this somewhere in my .emacs.d directory and load up it via

(use-package powerline-with-venv
  :ensure nil
  :after eshell-git-prompt ;; This is a dependency
  :load-path "lisp/themes/powerline-with-venv" ;; path to where I saved the file
  :config
  ;; Allow me to add this to the possible eshell prompt selections
  (add-to-list 'eshell-git-prompt-themes
               '(powerline-plus eshell-git-prompt-powerline-venv eshell-git-prompt-powerline-regexp))
  ;; Automatically set this as the default theme to use
  (eshell-git-prompt-use-theme 'powerline-plus))

It was pretty simple to do, honestly the longest time was to decided what color to use as the virtualenv part.

Making Eshell tell jokes

Sat, 28 Nov 2020 00:00:00 +0000

Whenever you start eshell, there is a banner that welcomes you. I decided I didn’t like having the same message everytime so I hooked up eshell to query some apis to return a joke on eshell startup. Before I show how to do that, you need to understand that eshell loads up modules (list of modules are in eshell-modules-list), and in that list there is a module called eshell-banner which is in charge of displaying the banner on startup (who would of guessed). With that in mind, we can do the following:

(use-package em-banner
  :defer t
  :ensure nil
  :custom
  (eshell-banner-message  '(funcall (nth (random (length gopar/request-jokes)) gopar/request-jokes))))

Note: I am using use-package but same functionality should be available with the use of eval-after-load

What I’m doing above is setting eshell-banner-message (which can be any s-exp) to a function that returns a string (the joke). The function itself is randomly selecting an element from gopar/request-jokes (which we will define in moment), once it has selected an element, it will call it (all the elements in the list are functions)

Here is how I’m defining the variables and how I’m querying the apis

(use-package request
  :defer t
  :ensure t
  :commands request
  :custom
  (request-timeout .5)
  (request-message-level -1)
  (request-log-level -1)
  :init
  (defun gopar/request-chuck-norris-joke ()
    "Return a chuck norris joke"
    (interactive)
    (concat (assoc-default 'value (request-response-data (request
                                                           "https://api.chucknorris.io/jokes/random"
                                                           :parser 'json-read
                                                           :headers '(("Accept" . "application/json"))
                                                           :sync t))) "\n\n"))

  (defun gopar/request-dad-joke ()
    "Return a dad joke"
    (interactive)
    (concat (assoc-default 'joke (request-response-data (request
                                                          "https://icanhazdadjoke.com/"
                                                          :parser 'json-read
                                                          :headers '(("Accept" . "application/json"))
                                                          :sync t))) "\n\n"))
  (setq gopar/request-jokes '(gopar/request-chuck-norris-joke gopar/request-dad-joke)))

First thing to notice is that I am using request which allows me to effortlessly make network requests \o/ Next, you can see I have 2 functions (gopar/request-dad-joke and gopar/request-chuck-norris-joke) that return a joke from their apis, and am storing both those functions in gopar/request-jokes (which is what eshell banner is using).

One thing to notice is that I am using the sync parameter in the request call. When using sync, the network call is synchronous which means that emacs will be unresponsive until the network call finishes. To me this isn’t a problem since I’ve set the timeout to half a second (It’s never taken more than that for me)

Lastly, I’m not doing any error handling. So if something blows up when doing a network call, eshell will break and you’ll have to close it and call it again. Haven’t had a need to implement it, but if you’re up to it, you can add that in :)

Eshell CD tricks

Fri, 27 Nov 2020 00:00:00 +0000

Eshell’s built in command cd has a pretty nice feature, which is keeping track of the directories visited and being able to jump to a directory matching the directory stack history.

You can see the directory stack via $ cd = and then either choose a number or directory to jump to (eg cd =foo or cd -3) both will jump to the foo directory

eg:

$ cd =
/Users/gopar
/Users/gopar/.emacs.d
/Users/gopar/projs
/Users/gopar/.emacs.d/org/work
/Users/gopar
/Users/gopar/.emacs.d/org
/Users/gopar/foo
$ cd =foo # cd's into directory foo
$ cd -7 # also cd's into foo

Another cool thing that it has is that you don’t have to type cd path/dir but simply path/dir in the prompt to cd into that directory. This works by checking if the input is a path, if not then fallback to using it as a command.

Eshells CD command is a pretty simple easy convinient tool :)

Book Review: Don't Make Me Think (Revisited)

Sat, 10 Oct 2020 00:00:00 +0000

I decided to pick up Don’t Make Me Think (Revisited) to learn more about UI/UX since I’m not that familiar with that topic. And well here is my review:

Pros

Author makes it easy to follow and read
Not technical so anyone can learn what he’s teaching.
Shows best practices and how to not make silly common mistakes.
Good examples on how to do useability testing

Cons

The mobile part is outdated (It was released in 2013) but you get the idea/points he’s making from the previous chapters
Wouldn’t recommend to someone who has UI/UX background since this seems like it’s only giving a high level over view in the subject.

Overall

The book is under 200 pages and would strongly recommend it for anyone wanting to learn more about UI/UX, or just in general on how the structure of websites came to be. It’s amazing that the things he goes through are pretty simple, but thats the point, simple is best.

Google App Engine's `DistributionNotFound: google-cloud-ndb`

Mon, 03 Aug 2020 00:00:00 +0000

When following Google’s migration guide for GAE 2.7 to GAE 3.7, they mention to start using their new ndb client google-cloud-ndb. This is straighforward until we ran into the following problem:

Traceback (most recent call last):
  File "/base/alloc/tmpfs/dynamic_runtimes/python27g/python27/python27_lib/versions/1/google/appengine/runtime/wsgi.py", line 240, in Handle
    handler = _config_handle.add_wsgi_middleware(self._LoadHandler())
  File "/base/alloc/tmpfs/dynamic_runtimes/python27g/python27/python27_lib/versions/1/google/appengine/runtime/wsgi.py", line 311, in _LoadHandler
    handler, path, err = LoadObject(self._handler)
  File "/base/alloc/tmpfs/dynamic_runtimes/python27g/python27/python27_lib/versions/1/google/appengine/runtime/wsgi.py", line 85, in LoadObject
    obj = __import__(path[0])
  File "/base/alloc/tmpfs/dynamic_runtimes/python27g/python27/python27_lib/versions/third_party/setuptools-0.6c11/pkg_resources.py", line 311, in get_distribution
    if isinstance(dist,Requirement): dist = get_provider(dist)
  File "/base/alloc/tmpfs/dynamic_runtimes/python27g/python27/python27_lib/versions/third_party/setuptools-0.6c11/pkg_resources.py", line 197, in get_provider
    return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
  File "/base/alloc/tmpfs/dynamic_runtimes/python27g/python27/python27_lib/versions/third_party/setuptools-0.6c11/pkg_resources.py", line 666, in require
    needed = self.resolve(parse_requirements(requirements))
  File "/base/alloc/tmpfs/dynamic_runtimes/python27g/python27/python27_lib/versions/third_party/setuptools-0.6c11/pkg_resources.py", line 565, in resolve
    raise DistributionNotFound(req)  # XXX put more info here
DistributionNotFound: google-cloud-ndb"

At first it seems like the system didn’t install google-cloud-ndb correctly, but the real problem is with the version of setuptools that our instance was using, which as you can see from the traceback is setuptools-0.6c11. If you look at the Googles list of supported 3rd party libs, that version is deprecated.

The fix should be easy, update your app.yaml to use the latest setuptools (as of this writing its 36.6.0).

...
libraries:
- name: setuptools
  version: 36.6.0 # You can also use `latest`
...

Unfortunately for us, the problem still persisted and we kept seeing in our logs that we were still using the old setuptools. After more debugging, we realized that another dependency we had in app.yaml was requiring the old version. My senior pointed out that if you look at google/appengine/api/appinfo.py inside Google’s SDK, you’ll see the following:

REQUIRED_LIBRARIES = {
    ('django', '1.11'): [('pytz', '2017.2')],
    ('flask', '0.12'): [('click', '6.6'), ('itsdangerous', '0.24'),
                        ('jinja2', '2.6'), ('werkzeug', '0.11.10')],
    ('jinja2', '2.6'): [('markupsafe', '0.15'), ('setuptools', '0.6c11')],
    ('jinja2', 'latest'): [('markupsafe', 'latest'), ('setuptools', 'latest')],
    ('matplotlib', '1.2.0'): [('numpy', '1.6.1')],
    ('matplotlib', 'latest'): [('numpy', 'latest')],
    ('protobuf', '3.0.0'): [('six', 'latest')],
    ('protobuf', 'latest'): [('six', 'latest')],
    ('grpcio', '1.0.0'): [('protobuf', '3.0.0'), ('enum', '0.9.23'),
                          ('futures', '3.0.5'), ('six', 'latest'),
                          ('setuptools', '36.6.0')],
    ('grpcio', 'latest'): [('protobuf', 'latest'), ('enum', 'latest'),
                           ('futures', 'latest'), ('six', 'latest'),
                           ('setuptools', 'latest')]
}

We were using jinja2 2.6 which required the deprecated setuptools. We decided to remove jinja2 from app.yaml and vendor it with the rest of the external 3rd party libraries. After that, the issue was fixed!

How I Stay Productive

Sun, 29 Mar 2020 00:00:00 +0000

I’ve been playing with tools and methods on how to make myself stay productive.

I’ve noticed that being physically present at work doesn’t make me productive at all, so I started playing with tools and methods to see if I can change this, and long story short, it has.

This is a quick rundown on tools and explanations on why I use them and what/how they work.

One thing before I start is that I greatly dislike moving my hand from the keyboard to the mouse, and back and forth. So most of these help with that.

Org Mode

This is an amazing free tool. It helps with organizing almost anything and everything. Todos, calendar/agenda, spread sheets, literate programming, etc. Highly customizeable in almost every way and runs inside of GNU Emacs which is an editor that I also mention in this list. Another good alternative is a tool called Notion,it’s been gaining a lot of popularity but I lost interest since I can’t control everything from the keyboard. Also, the free version can be very limiting if you end up going pretty deep in the rabbit hole.
Vimium

A free browser plugin that lets you use VIM keybindings to navigate. Pretty slick. \o/ I believe it’s only available in Chrome/Firefox, but if you’re like me and dislike using the mouse to move, then this will be a life saver.
Pomodoro

A technique to help you stay focus on work. It works wonders. Here’s the basic breakdown
- Work for 25 mins
- Take a 5 min break
- Work for 25 mins
- Take a 5 min break
- Work for 25 mins
- Take a 5 mins break
- Work for 25 mins
- Take a 20 min break
- Repeat all the steps
The thing that you must understand is that this is 25 mins of pure work, no distractions, no checking phone, social media, etc. And once the 25 mins are up, you must stop working and take a break. Otherwise you’re losing the reason as to why you’re doing Pomodoro.

Make sure that in the breaks you’re doing something that relaxes you or helps you get something else done. For example, I sometimes read a book, wash the dishes, do a quick exercise, etc, but once the break is over I get back to work. Staying strict on yourself is key to making this work.

I found it difficult at first but then it started to become easier and easier. So just stick to it \o/

Also, all of these numbers can be changed (eg, work for 30 mins and take 10 mins break) to make it work for you. I find it that the default numbers work for me and sometimes, I work an extra minute or two after the 25 mins are up just to wrap up. If I realize that I’m spending more than 3 mins extra on the task, I stop and take the break.
Emacs

An editor that’s pretty customizable and can nearly do anything and everything. The only editor I use for programming.

Although, it should be mentioned that it takes a while to learn since it’s primarily keyboard driven, of course you can use the mouse to move around but I’ve found that not many people do that.
Amethys

A tiling Window Manager (WM) for Mac.

When I was in Linux I went nuts with finding the perfect tiling manager and ultimately settled for stumpwm. If you’ve never heard of a window manager, it basically lets you controls all your windows and lets you decided what to with them via keystrokes. Pretty neat!

Sadly there the closest I found to that was Amethys, which works well but it just doens’t feel the same. Anyhow, if you’ve never tried Window Managers, I’d highly suggest checking one out.
12 Week Year

A method of actually achieving your yearly goals.

I’m no expert in this topic since I just started using it, but checking out the link above will go more into depth, but I’ll do a quick breakdown from what I understand.

You break up your year into 12 weeks. In those 12 weeks, you focus on achieving some type of goal (learning guitar, get fit, create a company, etc) and track your progress throughout the 12 week year. The point is, that if you have a year to do something, you’ll likely procrastinate and forget about it, but if you know it’s just around the corner, you’ll be more motivated.
Listening/Watching in 2X Speed

This isn’t really a tool but something that never occurred to me.

If you simple speed up a video/audio 2X, you’ll be able to consume the content faster and not loose any information while doing so. It takes a bit of practice to listen/watch things in 2X but once you’re there you can pretty much take on information much faster/quicker. Some people even do 3X which is a little insane for me.
Save Everything To Calendar

If you’re anything like me, then you probably forget things pretty frequently which is annoying. Especially if you have to do something, now I’ve gotten to the habit of saving everything and I mean everything to my calendar, no matter how small. This has helped a lot in realizing and prioritizing things no matter what they are.
Pen and Paper for problem solving

I never believed this worked, but actually writing problems when I’m stuck has helped me clear my mind and find the solution faster than usual. There really isn’t anything else I can add to this but to simply just try it, even if you were like me not believing it worked.

Of course, I’m still learning how to be more productive/efficient. Some of the ways I go about learning new things is by listening to podcasts. A podcast I really like is The Productivity Show which where I’ve learned quite a bit of things and I hope it’ll help you as well.