What are your favorite developer-efficiency tips?

Obs studio. I record myself while coding anything. I pretend to be a bigshot coding streaming sensation (even if its just for me). Its fun as well as very helpful in so many ways.

1. It helps me stay focus on the task at hand. One recording for each task 2. It lets me practice how to articulate stuffs. Its like blogging but ephemeral (because i wont upload this) 3. It helps me get motivated. Cant let my "thousands" of viewers down 4. It lets me review my blunders so i know how to watch out for them in the future 5. Its fun. I can let off some steam because i can curse all i want, my audience is 18+ and fine with some "sentence enhancers". I am Filipino but i record in English so i get that extra bonus practice.

Use procrastination against itself.

So basically, when procrastinating, we tend to justify our inactions: just 1 more minute on Twitter, just one last scroll on my newfeed, lemme just check this subreddit really quick.

With reverse procrastination, you trick your brain into doing your intended task: Ok lemme just open Visual Studio Code and edit this one file then im good, I'll just change this one line of code, I'll just do 5 pushups then i'll stop. Then when you're on your 5th pushup, you say "surprise mr lazy pants, im actually doing 10!"

Once you get to do that one task, try to trick again your brain into doing another simple, easy task and before you know it youre in "the zone".

Maybe it depends on the person, but for me personally, it works pretty good.

Perhaps OP is asking for tools, but no amount of dev tools can help if you dont have the motivation to begin.

The things I've benefited from most are not tools but practices.

- Question the work

Always be questioning whether the thing you're doing really needs to be done. Is there a way to not do it? Is there a way to do something better instead?

- Park downhill

Before putting a project or incomplete task away, make notes of what the next thing was that you were going to work on. This lets you bypass that 10 minute orientation getting back into the project the next time you pick it up.

- Keep a single todo list outside of your head

You can only have one master, so keep a single todo list in order of priority. Whenever something pops up on your radar, put it on the list in the right spot and immediately forget about it. Check the todo list a few times a day to make sure you're working on the right thing, and whether you need to communicate that something low on the list won't get done in time. Aggressively try to weed out the list and remove as many items as possible, preferably by not having to do them (by reassigning, by replacing or by reprioritizing).

Benefits: (1) not forgetting to do any work, (2) free up your mind to focus on work instead of meta-work, (3) clear priorities, (4) detect early when work is going to get delayed.

To combine this with park downhill I either keep the per-task notes on what to do next right in the list (in a details field of the todo item), or I keep it somewhere else and have just a single top-level item "finish X" in the master list.

Learn your environment and learn it well (over time). Every single thing that seems like weird arcane magic invented by brilliant wizards is just code or words, and often not a lot of it. Go find that code and read it. Docs are good, but they are almost never complete enough, because truly exhaustive docs would simply be the code [1].

Similarly, with something like CSS or OAuth that have specs, blog/tutorial content often leaves out important details that will be relevant to you. If you get stuck, quit wasting your time with them, and go read the damn spec! If you're still stuck after that, go read the implementation.

Wherever you work, there is probably a page with like hundreds of ugly graphs of it. Learn what the graphs mean.

When you do this, a day will come where someone will say "Kanye, I've been banging my head all day on why users are sometimes seeing outdated results after updating their page". A little thing will happen in your head, and you'll say "That sounds like replication lag/a weird quirk of the CSS spec/a bug I noticed in the graphics code", and suddenly you'll discovered that you are the wizard.

I'm not saying to do this instead of doing those other things, or instead of whatever you're supposed to be doing. I'm saying do it as part of your practice of making software. You're probably gonna do it for like 40 years, so might as well make the investment.

[1]: https://en.wikipedia.org/wiki/Map%E2%80%93territory_relation (Second time referencing this on HN today)

KEEP NOTES. Write everything down. Write down what you were thinking about, how you felt about decisions, things you tried for bug fixes. you never know when this stuff will be useful to you again.

I keep really basic markdown notes in a git repo, roughly one file per day with an ISO date name, but some things I give a separate file name (still with the iso date, but with some descriptive words) for things that might be good to re-access or are part of a series of similar notes (like a TIL file or a recurring meeting with the same person).

The biggest boost in productivity I've had in recent years is switching back to a statically typed language. TypeScript in my case. You can absolutely refactor and change course _so_ much quicker and with virtually no regressions at all. Just the other day we realized a feature I was building didn't handle an important case, and I had to really change the approach. Doing it in a JavaScript would have been dramatically harder.

The investment you have to make to really grok static typing is quite large. It took about 2 years for me to be really comfortable in TS. But you'll have to claw it out of my cold dead hands now.

Before switching to web dev, I used to work in Java, C#, C++, etc. But I've been away from static typing for about a decade now. I completely forgot how beneficial it is.

I just started at Stripe last year, and I found myself perform many mechanical tasks like:

* Converting seconds-from-epoch to a human readable date

* Select an id and pull info about it

At first, I tried to perform these mechanical tasks with some crazy shortcuts. But remembering shortcuts for every little flow is heavy.

Eventually, I've built a programmable tooltip on Mac OS X for these mechanical tasks.

I'd love for you to try it!

https://github.com/tanin47/tip

Probably an unpopular opinion but... Write your own text editor.

I've been working on my own (https://github.com/alefore/edge) as a side project and using it exclusively for about six years. I don't expect it to be very usable by other people (it's very customized for my workflows, I suppose; e.g., it's mostly useful for writing C++ and Markdown files) but, because I know it inside out (and I've invested in making it easy to customize through its extension language), it's very easy for me to adjust it to behave exactly the way I want it, which allows me to lower the friction for any operations I care about (and it abides very exactly to my principles/expectations for how an editor should behave; e.g. never block the main thread/UI while executing some operation such as opening a file). Because I don't have to use but a small set of computers directly (mostly my laptop and my workstation), this works well enough.

I don't know if overall it'll save me more time than it has taken me to implement it, but I do believe it allows me to move significantly faster than if I still used Vim or Emacs (or than most of my team mates), especially because it allows me to operate at a higher semantic level than otherwise, eliminating distractions from lower level details.

... and, I guess, it has been a lot of fun to implement it (and I've probably learned a bunch). I think it has played a role for me similar to that videogames have played for some of my friends (e.g., this weekend's challenge may be to generate visualizations for the logs I keep for every interaction I have with each file I've edited; implementing stuff like that feels similar to how in the past I felt about making progress in some videogames).

I can't say enough good things about a multiple clipboard manager. Not only is it useful to copy/paste multiple items in sequence, but it's a game changer to be able to quickly retrieve a code snippet, or URL, or CLI command you used recently; and/or, to trivially stash one just in case you'll want it later. (Primary downside: using a computer without multiple clipboards feels broken. What do you mean it "forgot" the thing I copied five minutes ago?)

My weapon of choice these days is LaunchBar [0]. Despite the clipboard history feature being bolted on to otherwise unrelated functionality, I love the low-friction keyboard shortcut: Cmd-\, arrow-down to the chosen item, release Cmd to automatically paste.

[0] https://obdev.at/products/launchbar/index.html

Write meaningful git commit messages, always. Even in stupid side projects that don't matter. Because then when you're at work, it will be second nature to write good messages, and your colleagues will absolutely appreciate it.

I've been following the keywords here: https://github.com/joelparkerhenderson/git_commit_message

A couple others have mentioned shell tricks. One of my favorites is using Alt-. (in Bash and Zsh) to insert the last argument of the previous command. Press it multiple times and it will cycle through the last argument of all previous commands. It's great for when you want to, say, `ls thing` and then `vim thing`.

Yesterday I went looking for a similar key that would insert a copy of the last argument on the current line, like for when you want to copy or rename a file to a similar name in the same directory, as in `cp some/long/path/to/foo.txt some/long/path/to/foo2.txt`.

I couldn't find a command for this, so I made my own Zsh "widget" and bound it to Alt-/ so now I can type `cp some/long/path/to/foo.txt` and hit Alt-/ to prefill the second arg. I put the code for it up here: https://gist.github.com/dceddia/0a45a88dd61cbdf1be023d0a8f15...

Don't push a commit with a new feature without tests and documentation. Even for your personal projects.

I started doing this a couple of years ago and it's hard to overstate the positive impact this has had on my macro productivity. I can come back to a project I haven't touched in six months and instantly start productively making improvements.

Tests and documentation really are for future you.

I usually comment with the same thing on these tip threads. And that is learn to rebind your keyboard. Make each key programmable modifier. Open apps, run scripts/macros instantly. My Karabiner config:

https://github.com/nikitavoloboev/dotfiles/blob/master/karab...

I go as far as binding keys to instantly type `console.log()` or `fmt.Println()` or the other language equivalent with my dot modifier key. Plus typing things like `Thank you` with dot+spacebar press.

https://github.com/nikitavoloboev/dotfiles/blob/master/karab...

The other tip that paid off in time is starting a wiki. And building an interface to access contents of the wiki instantly.

Wiki: https://github.com/nikitavoloboev/knowledge

Interface: https://github.com/nikitavoloboev/alfred-my-mind

This is a bit of a departure from the question you asked, but I'm always amazed how much people tend to hyper-tune their dev environments, when in reality, most of my time is spent thinking how not to write code. I get just as much work done on a completely vanilla macbook with VS code installed on it as my editor-obsessed peers with obsessively optimized setups can.

How much actual code are you writing? I'd be really concerned with myself if I am putting out so much code that I need to be concerned with my text input speed.

The REST Client VSCode extension[0] let's you send HTTP request from any file open in the editor. I use it to call the Cloudflare API to purge the cache of my site after I make changes. It's also really useful to test new APIs or quickly create a bunch of file/requests for the current project.

I use PHP on my landing page[1] so I can make changes and publish them immediately without any build step. This way, whenever I see something wrong with my site or have a new idea, I just open the editor, change the file, save and push all changed files through FTP to the server using the VSCode SFTP extension[2]. This means that I can instantly publish changes from VSCode without running any command, just by using shortcuts. This way I can make the changes immediately instead of having to create reminder tickets.

Automate the tasks you do often. For example, I had to download invoices from Envato every quarter, which was annoying because they don't have a button to export the PDFs of all invoices. I created a puppeteer script (headless Chrome) to download the CSV with the list of invoices, go to the URL of each of those invoices, print the file as PDF and save it into the correct folder. The automation part can also be just creating a faster build process, unit tests or even subscribing to notifications/alerts for a social site for the content you are interested instead of checking everytime if there's anything you might like.

[0]https://marketplace.visualstudio.com/items?itemName=humao.re... [1]https://usertrack.net/ [2]https://marketplace.visualstudio.com/items?itemName=liximomo...

Only work on one task at a time.

Do small tasks immediately - reply to that email, merge from master, do that CR, etc. Delaying small tasks tends to abandon them.

Keep your workspace clean (physical & virtual).

Update docs as you use them.

Say "No" often.

Set up a "scratchpad" repo for small experiments / learning, and phrase your learning as tests.

Not only does it get you practice writing code, you have evidence that what you think is actually true. And/or you can demonstrate it's not, when you learn otherwise. And if you push it somewhere, you can link people to it trivially (great for questions / teaching / bug reports).

It's pretty much guaranteed to be faster to hop in / build / run than your day-to-day repository (often by a few orders of magnitude), and testing some things forces you to learn some new tricks (concurrency tests / bug demonstrations are particularly complex). And personally I also recommend setting up an auto-rerun-tests loop (I prefer `entr`), which gets you very nearly repl-level feedback in any language. You can interactively explore to learn basically anything in any language.

I consider scripts to be functional documentation, so I write a lot of them, usually shell scripts but Ruby and Python, too. Any task that I might want to perform again, or tasks for someone else, gets a script if possible. All of my repos have a /scripts directory.

It can take some work to write and debug but in the end when it's working you know you have correct "documentation". Text and wiki documentation may look right but you can't be sure. Just today someone on my team was trying to create a particular build on Jenkins but was using the wrong build parameters, which were copied from wiki; the previous owner of the wiki had neglected a few changes. But the script worked!

Whenever I onboard to a new codebase, or try to learn more about an open-source project, I typically create personal notes that outline the structure and high-level “markers” that I want to remember and easily reference later.

Unfortunately those notes are disconnected from the codebase itself, and therefore, not as immersive/rich as I wanted them to be. So I created a tool that allows me to annotate codebases with my own walkthroughs/breadcrumbs/ToCs and then play them back at any time, directly within my editor. This workflow has provided a pretty nice productivity boost for me thus far, and has the benefit of enabling me to share these walkthroughs with others as well: https://github.com/vsls-contrib/codetour.

RTFM (as in Read The Fine Manual).

To me, the key for being productivity is understand throughly the "tools" we use: IDE, languages, libraries, framework cli, os, shell,... Read the implementation, the docs, the issue tracker, even the git history if you have time.

When I started to learn vim, I tried many popular distribution without understand each of the plugins they included. And I almost gave up learning vim. It's until I start to read the vim manual, learn the key strokes one by one and then building my own distribution, that's when I really know how to use vim. Even so, I still learn many great things from books like Practical Vim by Drew Neil (on Tmux, there's Tmux 2: Productive Mouse-Free Development)

I think you might already know that, but still shooting here for some quick tips. I don't have any shortcut, just that motto.

I love continuous feedback.

I set up automation in my development to run quick tools like code formatting, linting, and unit tests together.

I'll use tmux to split my terminal into an editor window on the right, and on the left, I'll have a tool like watchman or entr watching for changes to my code, and running those tools e.g.

    find . -name "*py" | entr make continuous

I also have some conventions about my tmux windows. Window 0 is where my music client lives in pane 0, and usually I'll run things like homebrew updates in other panes there.

I have a tmux keybinding that sends the "Next song" key to window zero pane zero. No matter where else I am in that terminal session, that keybinding skips to the next song.

I have another pair of tmux keys that activate/deactivate a particular openconnect vpn connection in a new pane, with a pause so i can see it complete, then it goes away. Part of my tmux status line is a single character - a C or a D, that indicates that vpn connection status as connected or disconnected.

- Your eyes are the only broadband connection into the brain, and they have millenia of pattern recognition training built into them. When solving problems like debugging, refactoring or data preparation, consider arranging information in a way that takes advantage of this. When it's in the right shape, irregularities or patterns will often just jump at you.

- Relatedly, your eyes are also extremely well-adapted to detecting movement and optical flow. Do these two images/texts/logs/terminal outputs/etc. differ? Do they differ if you ignore the hue/time stamps/pwd? Alt-tab back and forth between them and you will notice. (Beware of fancy effects or menus covering it though - it has to be an instant switch from one to the other).

- Become fluent in regular expressions (recommendation: https://regexcrossword.com/).

Programming in VR Desktop: https://github.com/SimulaVR/Simula (see the README for a link to a video of it in action).

This allows you to (i) distribute your work tasks intuitively across space; (ii) completely zap out all distractions within a VR headset; (iii) completely eliminate the mouse and work 100% on a keyboard (VR Desktop allows you to click and browse with eye gaze).

It takes a bit of practice to learn the keyboard shorcuts (spawning terminals, moving windows, etc with keyboard shortcuts), but once you learn it, it can feel very immersive/productive.

Learning keyboard shortcuts in my most used apps has proven very effective. I used to have a bunch of cheatsheets printed but now use CheatSheet for OSX - https://mediaatelier.com/CheatSheet/ and CheatKeys when on windows - https://cheatkeys.com

Save all bash history into a separate file. Even with a high limit, the default bash history functionality has bugs that will destroy your history now and then. With the following .bashrc settings I have commandline history going back a decade:

export HISTTIMEFORMAT='%F-%T'

PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND ; }"'echo \ bash$SHELLNO $PWD "$(history 1)" >> ~/.bash_eternal_history'

Contrarian opinion, but often doing things manually rather than automated will save you time. Writing/debugging a script is fun, but more often than not it would have been faster to do things the dumb way. If a task is risky or repetitive daily, then sure, but often developers confuse "writing a script because too lazy to manually do the work" vs "get the task done as fast as possible".

1. Learn a good plain text editor really well. Learn the shortcuts. Learn how to navigate text (skipping words, end/home, etc.) 2. Start using REPLs - saves a huge amount of time when trying to figure out small quips of logic. REPLs are extremely useful whether you’re an artist expert or a beginner. 3. Learn how to setup and use debugging tools. These are often a PIA to get properly working, but you’ll thank yourself later. For example I do a lot of Ruby/Rails and rspec work. Enabling byebug and leaning how to run rspec feature tests with the browser in non-headless mode can solve some really tough bugs. 4. Learn regexes (POSIX). They’re used everywhere and have pretty much identical implementations and syntax between languages; they can help you do anything from performing complex searches to parsing logs to writing your own search engines. 5. macOS: Cmd+` (backtick) lets you cycle between windows of the same application, e.g., all of your Chrome windows. This was a game changer for me. I still see a ton of people not even using alt-tab or using that awful expose crap. 6. Keeping your system “up”: Caffeine for Windows, Insomniax for macOS. One of my biggest annoyances is systems that automatically lock, sleep, or time out, wasting my time and mental energy on logging back in or waking my computer. 7. Taking more breaks and procrastinating. Yes! Procrastinating does wonders for me. Not sure why, but some of my best work is done after goofing off for hours. It’s probably counterintuitive to most of you, but surprisingly I can get more done by spending less time forcing myself to do it.

Close Hacker News. Close Reddit. Close Twitter. Close Facebook.

I only have only one real tip for you: learn to get in the zone.

When I am in the zone I have an intense desire to create a beautiful masterpiece in my chosen art and revel in its elegance and beauty. When I am in the zone outside distractions are eliminated and my mind is fully focused on the task at hand. When I am truly in the zone matters such as health, family, children, work and (when I was younger) even hunger or the need to sleep disappear; all that remains is the task. My brain has maximum cycles to iterate again and again until I achieve greater understanding and/or arrive at a solution.

I do not have very good general tips on how to get in the zone. I have some things that work for me, although not always. They include:

- Real-world isolation: These days where everyone is at home, I go to a corner in my garden where my family knows not to bother me.

- Virtual-world isolation: No emails. No browsing. No notifications of any kind. Phone on silent. Absolutely no Slack, Teams, etc!

- Friction-free programming environment: If the build takes 20 minutes, then it will be hard to remain in the zone. If the Mac has stuck keys get them fixed or buy a laptop from a different brand.

- Headphones with some favorite music: For programming I like trance, the more repetitive the better. I often use this youtube channel: https://www.youtube.com/user/MrLemilica2

- Review previous work on the subject: This acts as a brain warm up for me and usually puts me in the right mood.

- Some times work better than others: When I was younger it was far easier to get in the zone at night. These days I do not have that luxury because of family.

- Work on a problem that excites you: It is much easier to get in the zone when the subject matter interests you. It is harder (although still possible) when the subject is less interesting.

- No context switching: Choose a task and stick to it for at least a few hours.

- Get the non-enjoyable tasks out of the way: (This may not work for everyone.) I like to complete tasks that I do not enjoy (e.g. administrative or legal) first. I can then continue my work care-free instead of having this niggling thought in the back of my mind: "do not forget to respond to the lawyer".

Purchase a good IDE.

It'll provide similar benefits as writing your own text editor (which was suggested here).

It can also provide type hints and type checks for dynamically typed languages, thereby making them more like statically typed languages (also suggested in here).

Plus a good IDE will speed up searching as well as index the source code to make things click-able, thereby making large code bases or dependencies easier to navigate (also suggested in here).

So basically you can get a large chunk of the improvements that others have suggested in this thread simply by purchasing a good IDE :)

Have a sharpened pencil and stack of paper handy always. I can't say how many times it's saved me a lot of trouble programming some behavior because I was able to draw a picture of what I wanted it to do.

Automate repetitive tasks that can be automated. A task may take ten minutes. Automating it may take hours, and thus seems too expensive.

If this task is going to be done many times, then the automation WILL pay off. Running the automated task might take less time than the manual steps. And you can be doing something else.

The more of these kinds of tasks that you can automate, the bigger of a lever it becomes.

One of the oldest examples would be 'make'.

Learning basic *nix commands like sed, awk, and grep has helped me so much. I still frequently google/manpage them, but I often find myself thinking "I can do this with X in just a few seconds!"

Get out of the habit of watching TV.

Some downtime is important and healthy, but it is too easy to waste hours and stay up late staring at a television.

Not a developer tip specifically, but not wasting time and sleeping well is the best way to improve your efficiency at everything.

I keep two diaries, both MS Word documents. In one, I write summaries of what I read about -- papers, blog posts, books, and articles that interest me, along with the google search term, authors, URL, quotable quotes etc. In the other, I put together a free-form running log of projects I am working on, along with feature ideas, benchmark results (and the parameters used to get it),etc.

Why MS Word, you ask?

I am ordinarily an avowed plaintext person, and I have tried everything from various wiki formats, org-mode, markdown of every shape and stripe (even bought a few markdown editors), but they haven't worked for me. The reason is lack of WYSIWIG

WYSIWIG is a huge efficiency booster. Inline images, doodles of my own, colors, fonts, tables, inline math, greek and other symbols, all of it is right there in the original (not in a separate render), and is searchable.

Having all of it in one file is not really a problem performance-wise; I have had one file for the last 8 years. It is easy to back up and the chronology is clear, and it is easy to generate a table of contents.

Finally, having it on a google drive means that it is available/convertible to google doc if I need to access it from elsewhere. I do not rely on google docs to be the primary copy, because i don't want to rely on a working internet connection all the time. Offline works better for me.

Learn how to touch type.

I've worked with many programmers who don't know how to touch type. Anyone who uses a keyboard for more than an hour a day should learn to. It only takes about 2 weeks to learn all the keys, but it's a skill that'll save you thousands of hours throughout your entire career.

It completely baffles me that some developers haven't learned this basic skill. I've heard the argument that thinking is more important than typing. I counter that by saying if you learn to touch type, then it's easier to get into "flow" and your resistance to writing code drops pretty quickly.

What first came to mind for me is running. It’s very difficult for me to sit still for long periods of time, and so I end up switching tasks often. If I do a good run, I can stay still and focused for longer.

I believe longer contiguous periods of time developing are very helpful.

Easy, quick containers for Windows - Windows Sandbox. I've been putting Zoom in there to avoid installing it on my machine.

https://techcommunity.microsoft.com/t5/windows-kernel-intern...

If you have to look something up or solve something and it takes more than 2 minutes then write the solution down in your notes. Lots of times you'll need that again and you won't have to search for it again.

Shorten your feedback loop by using a continuous unit test or code runner. For JavaScript and it's variants I use WallabyJS (unit tests) and QuokkaJS (code). For C# there's nCrunch. For Python there's PyCrunch. And for Java and it's variants you can find InfinitTest

Here's a video by myself showing the JavaScript tools: https://youtu.be/MpFImvZrbDY

Great thread, thank you. Already seen a few things that I will look into.

For me, the transition from Bash to Zsh has been a huge efficiency boost. Mainly because of some great plugins for Zsh, such as z, zsh-peco-history (better history search), zsh-autosuggestions, and zsh-syntax-highlighting.

My blog post about setting up a Linux workstation describes this in detail: https://tkainrad.dev/posts/setting-up-linux-workstation/#swi...

The best thing is, there is no initial productivity hit. You don't miss out on any shell features that you are accustomed to.

If you work a lot with ssh, it is also worth the effort to create a proper .ssh/config that contains the most used hosts.

Never waste time logging in again:

scp ~/.ssh/id_rsa.pub me@[IP address]:/home/me/.ssh/authorized_keys

Make aliases for your most common commands. Someone in a similar thread posted a script for parsing your history to find them out. For me they were all git subcommands.

Write a script the second time you have to do something.

On a macro level: Don't work on doomed projects. Don't update tools in the middle of a project unless the current version is a roadblock.

I have such a simple setup but it's not for everyone. It also fails miserably if I'm working in an environment where I can't do almost everything I need to do from the command-line.

1) VIM with almost no special .vimrc

2) gnu screen (10 screens initialized via .screenrc)

- hotkeys Ctrl-Left (prev), Ctrl-Right (next)

- I tweak my $PS1 prompt so it will display which $WINDOW I'm on.

3) Not a tool, but a tip. Maintain a TODO list. I just open a text file and put some simple separators between projects I'm working simultaneously. But I go out of my way to ensure it's got everything I'm going to "DO". If I think of something, even if I'm not sure if I'll actually want to do it, I don't rely on my memory for ANY of it. If I'm not going to do it immediately I put it on my TODO list.

SCM Breeze[1] is one of the first things I install whenever I set up a new dev machine. Setting up bash aliases for git commands like `ga=git add` is nice, but SCM Breeze takes it one step further and automatically numbers each file in the git output. Then you can do `ga 1 2 5`.

[1]: https://github.com/scmbreeze/scm_breeze

Ergonomics.

You. Yes, you. Sit up straight. I know you aren't. Take a deep breath, belly breath. Try to let some of the tension out. There, much better :)

Also, TabNine, with a strong IDE and a good type system. The code practically writes itself. You can focus on higher level things.

Testing. Driven. Development. Once you define your goals, it's so much easier to hit them, both cybernetically and psychologically.

tabnine.com/faq

Asking lots of questions and thinking through the trade offs of more than one possible implementation before coding. Writing your implementation plan on paper especially helps find those unknown unknowns before you code. If you have trouble stating the problem and your solution in words, that indicates an unknown to investigate.

I.e. do a little writing to help avoid coding the wrong thing.

Learn how to use git's partial commit functionality `git add -p`, `git checkout -p`, `git reset -p`, etc.

Also get comfortable with rebasing. The most foolproof formula I've found is

   git rebase -i  [--onto ]

Using the two of those together, you can clarify your commits and have code that is actually reviewable rather than stream of consciousness spaghetti commits.

Makes reviews more pleasant and looking back through history more useful.

Also learn to use `git log -p` to look through the change history of files. Immensely more useful than `git blame`.

Honestly these posts seem like the equivalent of "lifehacks" for devs to me :D

The only protip I have is to think through a task on paper before you start writing code. Scope it if unclear, sequence it into small chunks, do more technical design if its a complex change etc. See if you can reuse existing code/libraries to do what you need.

1. Learn how to touch type so you never again look down.

2. Learn emacs.

3. Learn how to use emacs in a tight code and test loop.

Now you are invincible.

Build a snippet library.

You know those tiny useful functions to "parse any date into mysql friendly format", "check if string is a email or url", etc.

I have now hundreds of such functions in two huge files for the languages I work in most and it saves me a ton of time not having to reinvent the wheel or searching stackoverflow everytime.

Learning to write (simple) regular expressions will allow you to find and replace in text files fluently (capture groups are especially useful). It's a lot simpler than it looks initially.

Teminator.

I see many people suggest tmux, but I have not seen suggestions for my favorite terminal emulator.

Ctrl+Shift+E for vErtical split Ctrl+Shift+O for horizontal

This is a killer feature. It is also much better than tmux because scrolling up is naturally supported.

I always keep an instance of Teminator running full screen on one monitor and whenever I need another terminal, I just split the screen, or go to the relevant already open post of the screen.

Having a visual overview of all instances of very helpful and much better than using tabs.

The other killer feature in bash is Ctrl+r.

There is one single developer efficiency tip I can recommend: always dive deep.

While sometimes it makes sense to ask around for help on something, you should always spend 20 minutes checking the source of your favorite framework/company's library, and try to debug it yourself.

Speed up key repeat rate on MacOS: https://support.apple.com/guide/mac-help/set-how-quickly-a-k...

I developed my own gmail app script to accommodate my personal workflow, where all tasks and task-related information, including Gmail inbox, are organized and scheduled in the same hierarchy.

Here is why I think it makes me extremely efficient

1. I can group and nest together Emails, to-do’s, files and links that are related to the same goal, my lists are now much shorter and manageable and I can focus on my goals instead switching between gmail, todo’s etc..

2. Since my gmail Inbox is fully integrated with my to-do list, I don't need to manually and tediously maintain and synchronize them.

3. Scheduling a goal with sub-emails and tasks hide them and bring them back when I need them.This further reduces my clutter and makes sure I will not forget anything.

4. I can organize my plans and thoughts as I organize and drag inbox Emails, To-Do’s and Ideas into their related tasks.

5. Since every email has a natural place in my task hierarchy, I can quickly empty my Gmail Inbox and deal with email when dealing with their related tasks.

What made it stick for me was processing my gmail inbox (which I must do), inside my todo list, which quickly created a habit.

BTW I tried to market the solution and gave up, either most people think different or I am just a bad marketer.

There's many tools I've picked up over the years (sometimes on as needed basis, sometimes just for fun). The latter has been way more rewarding though in retrospect :) Instead of enumerating all of them, I think this course page does a great job of collating them by topic: https://missing.csail.mit.edu/

Get enough sleep. [1]

[1] https://arxiv.org/pdf/1805.02544.pdf

From my experience - multiple desktops, especially when having multiple monitors (and yes, you should probably get a second monitor).

If you don't use desktop switching: the basic idea is to have one desktop per task/bug/project. Lets you context-switch in a very organized manner.

If you're using them, good, but you may be surprised how many people don't!

Subscribe to every slack support channel and mailing-list that your end user (or people dealing with them) report issues to. Getting not just the filtered bug reports but also the questions and not-really-a-bug reports will really help you hone into what your product is supposed to do, not just what you think it should do.

Not a tool as you asked for but...

My tip is to change the requirements. Requirements are often poorly written and often contain a suggested implementation. Try to find the real problem, talk to your stakeholders and alter the requirements to find the easiest implementation.

I've saved months of work several times by doing this.

Using a modified international English keyboard[1] for programming.

My native language is Hungarian. We have 9 extra letters on the keyboard. Occupying the keys on the right side on the keyboard that used for brackets, semicolons, etc. on the US keyboard. These characters are moved to weird positions[1].

I use the English keyboard most of the time but modified it, so when I hit Caps Lock I can type Hungarian letters.

[1]: https://www.apple.com/uk/shop/product/MLA22Z/A/magic-keyboar...

[2]: https://en.wikipedia.org/wiki/QWERTZ#Hungary

I stopped using mouse with https://i3wm.org

It was the fasted way to use a computer I've ever experienced

TextExpander. You can take your most common code snippets, table names, etc., and have shortcuts that expand to the full length. I used shortcut expansion around 10-20 times every day, which saves me about a couple hours per month (based on their internal analytics report).

Don't use single-letter variable names like i, j, k. At least double them, like ii, jj, kk. If you do that then they're easy to grep for.

If you are working on the terminal a lot -- create handy aliases for common activities. For example, I have one to look at recently launched k8s pods. I have a "dracarys" alias which cleans out my environment and sets up a fresh test environment, etc.

Do the risky stuff first. Then rough out the whole thing, then refine it. Just like a sculptor.

The single biggest productivity boost is when I realized over 90% of my time is spent in Firefox+Terminal+Emacs.

Alt-tab drove me nuts so I bind F2/F3/F4 to a script that will cycle through instances of these 3 programs.

F2 is terminal, F2 again is next terminal, etc.

For any API, truely understand the architecture and problems it tries to solve, and only then will you stop fighting the API and become productive with it. Assumption - the person who designed the API actually knew what they were doing.

Learning statistical process control. I now make control charts for virtually anything, both professionally and personally. It's an insane productivity booster in that it tells me what the meaningful things to focus on are.

Buy a big whiteboard and use it often.

fzf.

Anywhere you want to find something, but particularly find something and do something with or to it, aliases or small scripts or plugins using fzf are great.

No specifics because I think it's a great Unix-spirited 'one thing well' and it's better to implement what works for you around it yourself, but I use it in: vim (filenames, file by contents, buffer names), password management, several git aliases for running commands with either a fuzzy found SHA or file, and more.

I was going to leave it at fzf, but as a bonus - bat. Use it in fzf previews, to see, with syntax highlighting, what you're selecting before you select it.

try to be 1% better as frequently as possible. (James Clear says daily, but even monthly will pay off a lot over a career)

For any self improvement where it's equally difficult, and it's only the changing cost, do your best to change immediately.

For example it's basically identical to write, but the latter is much much more valuable code. Identical effort, more value.

    log.Printf("thang blew up: %v", err) 
    // vs
    logrus.WithError(err).Error("thang blew up")

I try my best to seek out those "equally" difficult but better things and eat the change cost asap

Mildly off-topic but I find that exercising in the morning or during lunch break gives me the biggest efficiency boost ever.

Often you want to fix something quickly but run into a stupid problem -- you don't have the right data locally, or the wrong version of something, or an unrelated thing is broken, or something is undocumented and the person who knows isn't immediately available.

Thus you feel deflated, the energy is gone, and finally you move to something else.

Instead, fix that stupid thing, once and for all. Get to the bottom of it, automate all the future times it would happen again, don't just hit it but hit it out of the park.

Not always, because you won't do anything else, but often.

If you are using vim, you should definitely try using cvim or similar for chrome. You’ll most probably stop using mouse when in browser.

If it’s about tools, I would suggest trying out i3 and emacs. I’ve used vim+tmux for a couple of years. Slowly I’ve migrated to Emacs. Somehow, I like it a little more than vim. I still heavily use tmux.

For tmux, having a startup script with pre configured windows and panes can be helpful as well.

Having a dual monitor setup can also be very productive.

I personally try to avoid using mouse. Most of my hacks are targeted to achieve this.

Thinking before I code. I developed RSI, typing hurts after a few hours. Now, before I code anything, I really think about what I want to type, so I only type the minimal amount needed.

Share more. Whilst it might seem appealing to be "the one person" who can do something, it stops you moving on to new things. I've seen so many people go from "the guru" to "the bottleneck" because they've never done this. Sometimes due to "holding onto power" sometimes lack of time or motivations. Docs and explanations help the author to move onto new projects and new developers to pickup the old projects - a win/win.

I switch between commonly used apps with a single shortcut (e.g. ⌥E opens VSCode, ⌥D opens Chrome). Details http://frantic.im/macos-app-shortcuts

I use a simple TODO file for side projects https://blog.frantic.im/all/todo-file-for-personal-projects/

I've started using a debug diary, and it's been quite helpful. When I hit a problem, I often realize, "Wait, I've solved something like this before." I look through my debug diary and find entries related to what I'm working on now. It's saved me a bunch of time! Much better to read the solution I already came up with than to reinvent the same wheel for the 6th time.

Invest in your bash shortcuts! I have shortcuts for almost everything. To give you an example, I work in Rails + RSpec, each class has its own rspec shortcut:

`rspecs alexa_api` translates to `rspec spec/services/alexa_api_service_spec.rb`

`rspecm startup` translates to `rspec spec/models/startup_spec.rb`

I also have a bunch of other shortcuts for repeating tasks like expiring Redis, dumping a test database for local testing, etc.

Put every nugget of operational knowledge into small shell scripts and version control them. Never remember anything. Just run custom commands.

Total commander. For any OS. Is among the 1st 3rd party programs I install regardless if it's a Win or Android or Lin installation I do.

Remap the Caps lock button to escape.

I sometimes like to leave my source code in a dirty (uncommitted) format where I've left a comment with what I intend to do next. I quickly jot this down at the end of a workday, or if I need to run to a meeting or have a short conversation with a colleague. This reduces friction for me to get started coding next time I'm back by the computer.

Test driven development for my embedded systems work. I’ll never go back.

use AutoHotkey+SharpKeys to map macros, especially to keys on the home row. vim macros for recording on the fly. in general prefer keyboard shortcuts and command line tools.

regex is game-changing and regex101 is a great tool for it.

take notes and save snippets so you can refer back to them.

most underrated stack for productivity is proper diet + exercise + sleep.

Here is a real nice trick I have learn. How to give Error Code uniqueness numbers to Errors. That helps to find it later (find all) inside the code repository, know who code it and when.

I use this method: https://breakpo.blogspot.com/2020/05/simple-system-to-track-...

YYYYMMDD.XXXHHII

This give a full uniqueness for the Error Code number among the team. XXX is a unique number each one of the developers in the team have.

So an error code could be: 20190412.1001643 For programmer number 100, on the 12th of April 2019 at 4:43PM

This allows me to know how old is the code, and who to blame in no time :-)

Loved reading all of the comments here.

The biggest efficiency tip I've found it blocking all distracting websites via /etc/hosts when my computer wakes. Website blockers never worked perfectly for me because of edge cases. Ex: YouTube is distracting, but sometimes I want to watch a YT video, so I would disable the blocker and then forget to enable it again.

The /etc/hosts based approach with a wake script to re-add all distracting websites has worked amazingly well:

http://mikebian.co/how-to-block-distracting-websites-on-your...

Efficiently using multi-select to edit multiple lines simultaneously (e.g. cmd-d in Atom)

Emacs

I walk away from the computer when I need to think. Computers are so distracting!

Depending on time of year / weather I will either lie on a couch, pace in circles inside, or go for a walk, preferably with plants nearby, outside.

Avoid HN, Reddit, Facebook, twitter and other distractions during working hours.

Make use of .bashrc (I'm sure other shells have similar).

For projects I'll be working on for a while, rather than CD into a nested directory, activate a virtual envirnoment etc. I have simple bash shortcuts that perform all the steps. Also for SSHing and many other common task.

On this note, (probably doesn't apply to many here) but if you aren't lighting fast with a terminal and are dragging files around etc. you are usually doing work in a sub-optimal way. Learning bash (or some shell, I don't consider I'm an expert) a little more all the time really pays off. Likewise VIM.

This is a cool ask HN. Here are some things I do for frontend programming.

Things I like to use:

- org-mode for structured note taking (debug sessions, wip tasks, architecture, rubber ducking, other team details, scratch buffer is like a giant clipboard manager, used to use notes for tracking time on tasks and starting + ending the day too but now only do if there's a crunch)

- isolated testing envs where I can test apps

- automated e2e tests via Sauce Labs + WebDriver with emails for catching regressions

- adding APM tools like email alerts when prod goes funky

- quokka + wallaby.js + personal development setup for interactive programming (yes proprietary but super helpful)

- personal scripts for automating work (little stuff like: run triage steps while debugging, control tools that have bad UIs, add git hooks so I don't do as much dumb stuff, etc.)

- using code formatting like prettier, stylelint, eslint (other teams contribute code to us so breaking their work locally saves us time in the PR later)

- pay attention to where you get stuck, optimize

- pay attention to what you burn large amounts of time on, optimize

- lots of little debugging things like look for adjacent problems after finding a new issue (9 debugging rules book is a good starter)

- thinking about Rich Hickey talks (lol)

- get unstructured time everyday to just hang out with other developers on your team and talk about issues or new tools to try out (favorite part of my work). Other people are really smart and come up with good ideas!

Things I want to get:

- source maps for all frontend scripts pulled in only for my browser, works for all envs at work

- full source code search across the company at work (large group, thousands of projects)

- automated a11y and performance tests to catch regressions early

- automating small code changes across hundreds of projects

- somehow get rid of webpack's complexity (pipe dream, yeah right)

Edit: list formatting whitespace

autojump[1] is really helpful especially if you deal with huge codebases, like monorepos

[1] https://github.com/wting/autojump

Learning how to effectively use jq, which is kind of like awk + sed for json.

Don't over-optimize. I work for a large tech company and I see many developers make the mistake to over design/architect solutions prematurely, setup meetings with colleagues to discuss how the solution could be leveraged by others etc.. But 80% of the work that we do is pretty straightforward and simple Google search will give you the answers. So just timebox few hours and come up with a hacky solution(proof of concept) that works. More often than not this solution is pretty close to what you want and you've not wasted companies time.

Using https://github.com/github/hub has allowed me to fire off small pull requests at a high rate. It _almost_ makes pull request creation as lightweight as commits. This leads to smaller pull requests that are easier to review and likely easier to get a quick review on for because of that. Additionally, the reviewer is IMO likelier to approve the PR, leading to me being a much more productive engineer shipping things at a higher rate.

There are a lot of advice out there and looking for advice that you dont need and mental models that you dont need can be a huge waste of time. Know the problem you have at hand, and find out what people are doing to solve it, dont look for answers for problems you don't have.

Reading non-fictional books can be a waste of time. IE: I've read over 40 non-fiction books in 365 because I enjoy them. This approach is not time effective because you can usually put the wisdom and knowledge of one book in 1 paragraph

Know your context and know if those advice apply to you

Using virtual desktops regardless of OS. Also assign hotkeys to them. I always find other developers wasting so much time with their mouse to focus a window when they could have placed a group of related windows on a designated virtual desktop which they can navigate to quickly with keyboard shortcuts. Virtuawin is what I use on Windows, but for Macs or Linux, you can configure the native virtual desktop equivalent well enough to make usable with hotkey. It cuts down visual clutter and gives you focus on a specific task way better.

Work only on things that really matter.

Build admin and debug endpoints/pages into your services. Software is allowed to facilitate its own operation and troubleshooting, and it's almost always easier when it does.

fzf, ripgrep, fd, tree, fish shell with z plugin.

Align your windows near the middle ok your display.

Displays are always in wide shape and if you maximize windows size of any app, you'll be looking to the left quite a lot.

What I do is I just narrow every window, so the left edge starts from a little bit left of the center of the display, so if I'm reading a page on a web, my neck would mostly be moving around the center of my natural facing position.

You can put other small window to the blank space at the left or put some desktop files there to be always accessible.

My biggest boosters were:

- learning more then a few basic hot keys for zsh (things like ctrl-k, ctrl-r and beyond)

- mastering tiling window manager, today I can switch, compose, mix and match windows in a blink of any eye - it used to take seconds

- switch to minimal OS setup, tile WM, your basic terminal tool suit, browser + the few apps you actually need (saves you trouble configuring all of that extra crap + updating it daily)

- find time to read MAN on every program you use daily, you will find lots of hidden gems in there

Be absolutely relentless in searching and discovering new tools, and throwing old ones away when they aren't the best anymore.

Note this can be painful to leave an old favorite behind.

Autojump - for quickly jumping between directories

https://github.com/wting/autojump

Use Makefile, Readme and .env files more effectively (mainly to avoid WTF moments when you don’t remember why you did something when you did it).

I am not good at remembering commands particularly when you have to deal 10 different technologies (Kubernetes, Docker, Framework specific stuff) so create some standard wrapper functions as make shortcuts and document them in Readme.

JIT compiling

Just in time compiling means, you can modifiy your programm at runtime. I had wasted so much time in the implement-compile-run-debug-repeat cicle. Just the naviagtion to the part i want to debug had me cost a lot of time. With JIT you can implement and debug at the same time. Debugging every single change and seeing the effects helped me to avoid a lot of bugs.

I recently learned iTerm2 (on MacOSX) allows me to select and copy text from previous command, using keyboard only. https://kevinjalbert.com/iterm2-mouseless-copy/ I've always been annoyed having to reach for a mouse for this.

Started my personal wiki using dokuwiki. I sync it between my Ubuntu laptop and Android phone using Syncthing (on the phone I use Nginx on Termux to serve the pages). Very satisfying to have my notes available everywhere without having to share them with cloud etc (I already backup everything locally and on Backblaze so they are safe anyway).

I use a 4k TV as a monitor - I can easily see full size my code editor, terminal output, a page of documentation and the web app/site I'm working on all at once. It cuts down tremendously on the back and forth switching and reloading of things that don't feel like they take up much time but do materially eat into things.

Introducing tiling manager to my workflow: [0]i3

Like tmux in terminal, i3 for every GUI app. On a dedicated screen / workspace I run apps like browser, slack etc - and having them split the space automatically is super convenient.

[0] - https://i3wm.org/screenshots/

Comments: you'll thank yourself later.

Learn Unix power tools, study their options (`man` is your friend) -- and use pipes to combine their powers.

Instead of commenting your code once in a while make it default. I started always commenting and documenting my code (even the simplest parts for consistency) and it dramatically improved my productivity when I revisited if afterwards.

10x multiplier if you're working with a team.

I used to use AutoHotKey several years ago. It provides remapping hotkeys, text expansion (snippets), macro on operating system level, etc. But it only runs on Windows. :( It's the very few tools on Windows I miss.

Now I use Spotlight/Alfred/Dash/aText instead.

This vid changed my life:

https://www.youtube.com/watch?v=_o7qjN3KF8U

Please watch it. You can choose to be part of the wheat or the chaff, and if you're not hustling, what's the point?

I use 2 PCs at my desk with Multiplicity as a KVM it has made me more productive as a game dev.

C-r for interactive history search

Decent git aliases: https://git-scm.com/book/en/v2/Git-Basics-Git-Aliases

Ctrl + space (browser)

Alt + space (terminal)

On Firefox:

Spacebar (pagedown) | Shift + spacebar (pageup) | Ctrl + tab (cycle between last recent opened tabs) | Cmd + number (go to tab of number) | Cmd + K (go to search box) | Cmd + L (go to address bar)

Use Vim and forget the mouse

BetterSnapTool for snapping windows on your computer, been using it for years. I'm assuming every dev takes advantage of screen real estate, but if you aren't, you should.

Use Emacs for everything.

For me, having OhMyZsh installed with a couple of plugins such as: git, docker, vscode has greatly improved my efficiency as the amount of typing has reduced considerably.

The Pragmatic Programmer, which was recently published its 20th Anniversary Edition, talk about these tips in whole book, from The Basic Tools to Pragmatic Starter Kit.

Use Emacs.

(Really, use any fully extensible editor and take the time to learn it well. I'm told Vim fits the bill too; my personal experience just happens to be with Emacs.)

Emacs key bindings work system-wide on macOS. Having the same keys to navigate no matter what app you’re in is a huge productivity booster.

I seem to be more efficient when I stay off HN :-)

Rather than using cmd-tab, using pre-defined shortcuts to jump to the right [workspace,window,tab]; make sure to disable any animations.

Get a larger, higher resolution monitor. And when you can't do that get another monitor.

My main one's 5k2k and I could still use more space.

Actually learn how your tools work. Don't treat things as black boxes, tear the cover off and learn what is actually happening.

Eleven hours in and no mention of AutoHotKey?

Shame on you HN!

Working with a very small sampled dataset when doing anythin g'big data' or 'AI' related.

The space you work in is important. Open plan offices are one of the most destructive forces to productivity

speech-to-text for writing (reports, designs) anything more than a paragraph or two.

much faster than I Can type.

If you have to be that efficient at a particular job then you need to find another job.

Find when you get into the zone. I get into the zone at almost exactly 5pm every day.

Know your IDE inside out. Not only the features, but also the keyboard shortcuts.

Your IDE + a linter + a test suite = level up into any language super quickly

The first step in programming is away from the computer.

Spock testing framework. To let me do TDD.

Documentation > email > meeting.

1. I use Visual Code with carefully chosen extensions that alert me all the time about error.

2. I have enabled linter autofix on safe. It fixes a lots of stuff very good fast.

3. I wrote several own extensions. One for example shows error in the code when i do some mistakes i normally do. It also boosts my speed because i dont go through the whole process of finding these errors.

4. Since i code using TypeScript and Angular i use a lots of OOP and composition to reuse easily and modify code fast. And have less errors. OOP gives great propert and method suggestions in VSC so there is less space for errors.

5. I have a lots of generators and snippets custom for my projects. So writing similar things is blazing fast.

6. I dont overcomplicate stuff. Write everything as simple as possible so it is easy to refactor and modify and understand.

7. I use bash with a menu to have complicated operations like git operations to be done easily. Without clicking with mouse. It is a boost.

8. I have written also some software in C# that operates on the TS code base. I use it to generate some more complicated stuff that includes multiple files at once. I use code comments to put for example snippet examples into Angular code. Than a C# app looks for these in whole project and generates snippets for VSC automatically.

9. An extension for VSC executes tests one by one. I can choose test to start. It is faster than start all each time.

10. CI/CD, unit testing, linting, end to end tests give a boost if done right.

11. I side from solutions that are hype but cause loads of code to be written. For example some silly state management libraries. Overkill.

12. My PC is packed with best hardware, updated regularly to be fastest as possible. Since every second you wait ia a second you waste. PC ia better because you can upgrade it cheaper than laptop. Remote access is the key if you want use laptop.

13. Good sleep and diet, sports is essential for good performance. And music.

14. I never go into the zone if i am not 100% sure what and how to do stuff. In the zone you arw blazing fast, but be careful to not write useless code because of bad approach.

15. Notes notes notes. For everything. Refactored often. JIRA as a single source of tasks. Notepad as a detail task list.

16. I adjust tasks to the time of day and my mental focus. Some easy task for first half hour, and than the big ones for the rest of the morning.

17. I have wrote a lots on keyboard to have very high speed. It saves me time writing (actually you need to use keyboard when you are a dev anyways) and less wasted time for typos.

18. All notifications off. All spam sms, emails, calls off. No distractors.

19. I never code when i am not 100% sure what and how to do it. No guessing, always asking. A lots of wasted time saved. Never being ashamed to ask even the most stupid question.

20. I always remember that things take time and not stress too much about it. Stress harms performance if too high. But also some stress can let you go into the zone. And this is magical place to be in.

I enjoy coding. Always had. For 20 years.

Using pomodoro timer. That also means no Reddit, Hackernews, or Lobste.rs in that 25 minutes

Get other hobbies.

know your keyboard shortcuts

Over the past ~half year I gradually established a workflow consisting of a simple directory structure, a handful of bash-aliases and chromium profiles. It looks like this:

Each project gets its own directory somewhere in my $home with some subdirs. There might be various others specific to the project-domain, but these are the most common:

• notes/ contains plaintext files of everything i write down. File-name structure is :, e.g. 2020-05-09:call (:call are the most typical ones). As others have also suggested, I take a lot of notes for record keeping & plannning purposes.

• workspace/ contains all source code repositories, or other files necessary to work. Pretty much anything I might touch while coding.

• auth/ for things like ssh public keys used on the project

• downloads/ Project-specific downloads.

Then I create new entries in my ~/.bash_aliases that "get me" right into the coding-env of a project. Say I work on a python project, I might have an alias that looks sth like:

  alias fb='cd ~/fooproject/workspace/foobot && echo "loading virtualenv..." && source .venv/bin/activate';

On of my current side-projects is a full-stack clojure(-script) app with these aliases:

  alias foh='cd ~/opendecks/workspace/foh';
  alias fohj='cd ~/opendecks/workspace/foh/src/clj/opendecks/foh';
  alias fohs='cd ~/opendecks/workspace/foh/src/cljs/opendecks/foh';

First one gets me into the the source-root of the project, the other two into respective sub-paths for back- and front-end. These aliases allow me to immedeiatly "jump into a project" from any open terminal.

Lastly, I started employing chrome/chromium's user-profiles to seperate browsing for each project. This isolates work-related browsing from my personal activity (cookies, logins, passwords etc), and provides a nice cognitive barrier against procrastination. I'm not logged into any social networks on those work-profiles and switching to my private profile to browse facebook is a more concious act than opening a new tab in the current window. Each browser profile is set-up to save all downloads to the project-specific `./downloads` directory, again not to mingle (potentially confidential) resources.

I haven't automated any of the above steps, because it's so simple and takes me at most 10-15 mins to create a new instance. This has worked really well for me so far, because it clearly seperates almost all resources associated to a project, while being friction-less in tooling/switching between workspaces (versus e.g. waiting for a VM or docker instance to start). Another nice side-effect is that I can easily archive or clean-up past projects.

step through debugger

Learn to touch-type properly. I'm not a shit hot typist or anything, but it does make hours on a keyboard more pleasant. And (hate me) I do judge other devs on it. If someone can't be bothered to invest a few tens of hours on such a key productivity enhancement then what does that say?

Node.js: you can share code between client and server side.

Typescript: you don't need to remember the arguments of a function or return types. Easy to refactor. Just no brainier. I also use it for all my config like webpack config with ts-node or ts-node-dev for auto reload.

Auto format all your code with 1 command. Prettier or lint fix. But that's basic.

Don't ever write global css. Use emotionjs or styled components. Scoped css it's a delight.

If you notice all my tips helps you to reuse the code you write. Therefore write less code, more efficient.

Plan all your stories ahead. Then do one at the time. Then mark it done. Prioritize.

Avoid being an early adopter of new technology despite everyone on HN raving about it. Instead focus on solving actual business needs that grow revenue or profit margins.

password manager